c++ - sirve - Obtenga un std:: ostream ya sea de std:: cout o std:: ofstream(archivo)

libreria para cout dev c++

Question

¿Cómo puedo unir std::ostream a std::cout oa un objeto std::ofstream , dependiendo de una determinada condición del programa? Aunque esto no es válido por muchas razones, me gustaría lograr algo semánticamente equivalente al siguiente:

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

He visto algunos ejemplos que no son a prueba de excepciones, 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 de cout o el flujo de archivos de salida a out. Después de eso puedes escribir "salir" y terminará en el destino correcto. Si solo quieres que todo vaya a std::cout vaya a un archivo, también puedes hacer

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 una excepción segura. Posiblemente quiera escribir una clase que haga 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

Esto es a prueba de excepciones:

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 ha abordado esto en el artículo Switching Streams (Gurú de la semana) .

Answer 3

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

Answer 4

Siendo un novato en C ++, no sé si esto es a prueba de excepciones, pero así es como lo hago habitualmente:

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