Ahora en http://dacap.com.ar/blog
Los nuevos posts relacionados a C++ aparecerán bajo la categoría cpp, se pueden filtrar si la URL contiene /cpp/ (feed con posts de C++ usando Yahoo Pipes).
Otra mejor forma es directamente seguirnos en nuestra página de Google+ donde voy a estar publicando enlaces a los posts.
#include <iosfwd>De esta forma podemos utilizar los tipos ostream, istream, etc. sin necesidad de traer la definición de todas las clases de entrada y salida. Generalmente deberíamos utilizar el <iosfwd> en nuestro .h cuando no hagamos un mayor uso que sólo referenciarlas. Un ejemplo:
#ifndef EMPLEADO_IO_H #define EMPLEADO_IO_H #include <iosfwd> // forward declaration de ostream class Empleado; // forward declaration de nuestro tipo // Aquí no necesitamos conocer el tamaño ni de Empleado, // ni de ostream, podemos compilar sólo con sus forward // declarations. void write_empleado_en_formato_binario(const Empleado&, ostream&); #endifRegla: Siempre intenta usar las forward declarations antes que incluir los archivos de cabecera que definen las clases, los cuales suelen mostrar detalles de implementación que son propensos a cambiar. Siguiendo esta regla mejoraremos el tiempo de compilación y la cantidad de archivos a compilar al realizar una modificación en un .h.
Para más información, ver la sección 27.3 Forward declarations [iostream.forward] del último borrador público del estándar de C++
¡Feliz año nuevo!
http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-835TLos puntos tratados que no podes dejar pasar por alto:
#include <queue>
#include <list>
using namespace std;
class Barco {
public:
void subirPasajero(const Pasajero& pasajero);
void abandonarBarco(list<Pasajero>& pasajerosEnOrden);
private:
priority_queue<Pasajero> pasajeros_;
};
void Barco::subirPasajero(const Pasajero& pasajero)
{
pasajeros_.push(pasajero);
}
void Barco::abandonarBarco(list<Pasajero>& pasajerosEnOrden)
{
while (!pasajeros_.empty()) {
pasajerosEnOrden.push_back(pasajeros_.top());
pasajeros_.pop();
}
}
enum Prioridad { Capitan, Hombre, Mujer, Ninio };
class Pasajero {
public:
Pasajero(Prioridad p) : prioridad_(p) { }
bool operator<(const Pasajero& otro) const {
return prioridad_ < otro.prioridad_;
}
Prioridad prioridad() const { return prioridad_; }
private:
Prioridad prioridad_;
};
#include <iostream>
using namespace std;
int main()
{
Barco titanic;
titanic.subirPasajero(Pasajero(Capitan));
titanic.subirPasajero(Pasajero(Mujer));
titanic.subirPasajero(Pasajero(Hombre));
titanic.subirPasajero(Pasajero(Mujer));
titanic.subirPasajero(Pasajero(Ninio));
titanic.subirPasajero(Pasajero(Hombre));
titanic.subirPasajero(Pasajero(Ninio));
// ...
list<Pasajero> pasajeros;
titanic.abandonarBarco(pasajeros);
for (list<Pasajero>::iterator it = pasajeros.begin(),
end = pasajeros.end(); it != end; ++it) {
cout << it->prioridad() << "\n";
}
return 0;
}
El anterior ejemplo imprime:3 3 2 2 1 1 0Lo que significa que, sin importar el orden en el cual agregamos los pasajeros, primero extraemos los niños, luego las mujeres, los hombres, y finalmente el capitán.
#include <iostream>
using namespace std;
int main()
{
cout << "A\n";
cerr << "B\n";
clog << "C\n";
return 0;
}Al ejecutarlo, obtenemos por pantalla las tres líneas:
test.exe [ENTER] A B CPero resulta interesante saber que podemos redireccionar el STDOUT a un archivo y el STDERR a otro. Ejemplo:
test.exe 1>stdout.txt 2>stderr.txt¿Qué demonios es 1 y 2? Los archivos tienen un descriptor que los identifica, 1 es para la STDOUT, y 2 para STDERR. El signo mayor (>) significa que "quiero redireccionar toda la salida de texto que vaya para este descriptor a este archivo". En el anterior ejemplo logramos obtener dos archivos distintos, stdout.txt que contiene una línea (A), y stderr.txt que contiene dos líneas (B y C).
Generalmente, los logs van a un archivo, no a la pantalla. Aunque por defecto clog mande todo a STDERR, resulta útil redireccionar este stream a un archivo propio (por ejemplo, test.log). De esta forma, podemos hacer uso de clog para "loguear" todo lo que nuestro programa hace.
¿Cómo se redirecciona clog? Básicamente los streams de C++ tienen un streambuf asociado, y éste es el realmente encargado de leer y escribir datos (en la pantalla, en un archivo, en un string en memoria, etc.). Por lo tanto, si creamos un fstream y le colocamos su propio streambuf a clog, podemos usar clog como un "alias" del fstream original (clog va a estar compartiendo el mismo streambuf que el fstream). El código resultante es bastante sencillo:
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
// Creamos un archivo de salida para logging.
ofstream test_log;
test_log.open("test.log");
// Obtenemos el streambuf actual de clog (esto
// lo usaremos luego para restaurar el streambuf
// a su valor original, por si las moscas).
streambuf* old_rdbuf = clog.rdbuf();
// Reemplazamos el streambuf de clog con el del archivo.
// Ahora ambos streams utilizarán el mismo streambuf (es
// decir, escriben en el archivo test.log).
clog.rdbuf(test_log.rdbuf());
// Hacemos lo mismo que el ejemplo original.
cout << "A\n";
cerr << "B\n";
clog << "C\n";
// Restauramos el viejo streambuf de clog.
clog.rdbuf(old_rdbuf);
// Cerramos el archivo.
test_log.close();
return 0;
}Y listo, ahora podemos hacer lo mismo que antes:
test.exe 1>stdout.txt 2>stderr.txtCon lo cual obtenemos tres archivos:
