C'è un modo per creare un oggetto flusso di output comune da stampare sulla console e su un file in C++?

Question

Sto scrivendo un codice in cui devo stampare gli stessi dati sulla console e su un file. C'è un modo per popolare un oggetto di flusso di output comune e quindi visualizzarlo su console usando cout ed esportarlo in un file, usando le librerie fstream e iostream?

Answer 1

Sicuro. Dovresti semplicemente creare un buffer di flusso adatto che probabilmente memorizza su altri buffer di flusso che scrive internamente. Utilizzando questo buffer di flusso, devi creare un std::ostream a cui stai scrivendo.

Per esempio, ecco un semplice implementazione di questo approccio:

#include <streambuf> 
#include <ostream> 

class teebuf 
    : public std::streambuf 
{ 
    std::streambuf* sb1_; 
    std::streambuf* sb2_; 

    int overflow(int c) { 
     typedef std::streambuf::traits_type traits; 
     bool rc(true); 
     if (!traits::eq_int_type(traits::eof(), c)) { 
      traits::eq_int_type(this->sb1_->sputc(c), traits::eof()) 
       && (rc = false); 
      traits::eq_int_type(this->sb2_->sputc(c), traits::eof()) 
       && (rc = false); 
     } 
     return rc? traits::not_eof(c): traits::eof(); 
    } 
    int sync() { 
     bool rc(false); 
     this->sb1_->pubsync() != -1 || (rc = false); 
     this->sb2_->pubsync() != -1 || (rc = false); 
     return rc? -1: 0; 
    } 
public: 
    teebuf(std::streambuf* sb1, std::streambuf* sb2) 
     : sb1_(sb1), sb2_(sb2) { 
    } 
}; 

class oteestream 
    : private virtual teebuf 
    , public std::ostream { 
public: 
    oteestream(std::ostream& out1, std::ostream& out2) 
     : teebuf(out1.rdbuf(), out2.rdbuf()) 
     , std::ostream(this) { 
     this->init(this); 
    } 
}; 

#include <fstream> 
#include <iostream> 

int main() 
{ 
    std::ofstream fout("tee.txt"); 
    oteestream tee(fout, std::cout); 
    tee << "hello, world!\n"; 
}