Obtener un std :: ostream ya sea desde std :: cout o std :: ofstream (archivo)

Question

¿cómo puedo enlazar un objeto std::ostream a cualquiera std::cout o para std::ofstream, en función de una determinada condición programa? Aunque esto no es válida, por muchas razones, me gustaría lograr algo que es semánticamente equivalente a la siguiente:

std::ostream out = condition ? &std::cout : std::ofstream(filename); 

He visto algunos ejemplos que no son una excepción de seguridad, tales como uno de http://www2.roguewave.com/support/docs/sourcepro/edition9/html/stdlibug/34-2.html:

int main(int argc, char *argv[]) 
{ 
    std::ostream* fp;           //1 
    if (argc > 1) 
    fp = new std::ofstream(argv[1]);       //2 
    else 
    fp = &std::cout           //3 

    *fp << "Hello world!" << std::endl;       //4 
    if (fp!=&std::cout) 
    delete fp; 
} 

¿Alguien conoce una mejor solución de excepción segura?

Answer 1

std::streambuf * buf; 
std::ofstream of; 

if(!condition) { 
    of.open("file.txt"); 
    buf = of.rdbuf(); 
} else { 
    buf = std::cout.rdbuf(); 
} 

std::ostream out(buf); 

Eso asocia el streambuf subyacente del flujo de archivos de salida o salida a out. Después de eso puedes escribir "salir" y terminará en el destino correcto. Si lo que desea es que todo va a std::cout entra en un archivo, puede hacer aswell

std::ofstream file("file.txt"); 
std::streambuf * old = std::cout.rdbuf(file.rdbuf()); 
// do here output to std::cout 
std::cout.rdbuf(old); // restore 

Este segundo método tiene el inconveniente de que no es seguro excepción. Posiblemente quiere escribir una clase que hace esto usando RAII:

struct opiped { 
    opiped(std::streambuf * buf, std::ostream & os) 
    :os(os), old_buf(os.rdbuf(buf)) { } 
    ~opiped() { os.rdbuf(old_buf); } 

    std::ostream& os; 
    std::streambuf * old_buf; 
}; 

int main() { 
    // or: std::filebuf of; 
    //  of.open("file.txt", std::ios_base::out); 
    std::ofstream of("file.txt"); 
    { 
     // or: opiped raii(&of, std::cout); 
     opiped raii(of.rdbuf(), std::cout); 
     std::cout << "going into file" << std::endl; 
    } 
    std::cout << "going on screen" << std::endl; 
} 

Ahora, pase lo que pase, std :: cout está en estado limpio.

Answer 2

Ésta es una excepción de seguridad:

void process(std::ostream &os); 

int main(int argc, char *argv[]) { 
    std::ostream* fp = &cout; 
    std::ofstream fout; 
    if (argc > 1) { 
     fout.open(argv[1]); 
     fp = &fout; 
    } 
    process(*fp); 
} 

---

Editar: Herb Sutter se ha ocupado de esto en el artículo Switching Streams (Guru of the Week).

Answer 3

std::ofstream of; 
std::ostream& out = condition ? std::cout : of.open(filename); 

Answer 4

ser un novato en C++, no sé si esto es una excepción-seguro, pero así es como normalmente lo hago:

std::ostream& output = (condition)?*(new std::ofstream(filename)):std::cout;