Implementazione di un no-op std :: ostream

Question

Sto cercando di creare una classe di registrazione che abbia membri come Info, Error etc che possano essere configurati in output su console, file o in nessun posto.

Per efficienza, vorrei evitare il sovraccarico della formattazione dei messaggi che verranno gettati via (ovvero i messaggi di informazioni quando non sono in esecuzione in una modalità dettagliata). Se implemento uno std :: streambuf personalizzato che viene esportato da nessuna parte, immagino che il layer std :: ostream continui a fare tutta la formattazione. Qualcuno può suggerire un modo per avere uno std :: ostream veramente "nullo" che eviti di fare alcun lavoro sui parametri passati ad esso con <<?

Grazie.

Answer 1

Per evitare che le invocazioni operator<<() eseguano la formattazione, è necessario conoscere lo streamtype in fase di compilazione. Questo può essere fatto con macro o con modelli.

La mia soluzione modello segue.

class NullStream { 
public: 
    void setFile() { /* no-op */ } 
    template<typename TPrintable> 
    NullStream& operator<<(TPrintable const&) 
    { /* no-op */ } 
} 

template<class TErrorStream> // add TInfoStream etc 
class Logger { 
public: 
    TErrorStream& errorStream() { 
     return m_errorStream; 
    } 

private: 
    TErrorStream m_errorStream; 
}; 

//usage 
int main() { 
    Logger<std::ofstream> normal_logger; // does real output 
    normal_logger.errorStream().open("out.txt"); 
    normal_logger.errorStream() << "My age is " << 19; 

    Logger<NullStream> null_logger; // does zero output with zero overhead 
    null_logger.errorStream().open("out.txt"); // no-op 
    null_logger.errorStream() << "My age is " << 19; // no-op 
} 

Dal momento che si deve fare questo al momento della compilazione, è naturalmente del tutto inflessibile.

Ad esempio, non è possibile decidere il livello di registrazione in fase di esecuzione da un file di configurazione.

Answer 2

Probabilmente avrete bisogno di qualcosa di più della semplice formattazione del testo e del filtro dei messaggi. Che dire del multithreading?

Implementare la sincronizzazione del filtro e del multithreading come responsabilità di una classe separata.

Tuttavia, la registrazione è un problema non così semplice, e vorrei provare a utilizzare le soluzioni di registrazione esistenti, invece di svilupparne una nuova.

Answer 3

Un google veloce ha fornito questo esempio che potrebbe essere utile. Offro garanzie, se non che si compila e funziona :-)

#include <streambuf> 
#include <ostream> 

template <class cT, class traits = std::char_traits<cT> > 
class basic_nullbuf: public std::basic_streambuf<cT, traits> { 
    typename traits::int_type overflow(typename traits::int_type c) 
    { 
     return traits::not_eof(c); // indicate success 
    } 
}; 

template <class cT, class traits = std::char_traits<cT> > 
class basic_onullstream: public std::basic_ostream<cT, traits> { 
    public: 
     basic_onullstream(): 
     std::basic_ios<cT, traits>(&m_sbuf), 
     std::basic_ostream<cT, traits>(&m_sbuf) 
     { 
      init(&m_sbuf); 
     } 

    private: 
     basic_nullbuf<cT, traits> m_sbuf; 
}; 

typedef basic_onullstream<char> onullstream; 
typedef basic_onullstream<wchar_t> wonullstream; 

int main() { 
    onullstream os; 
    os << 666; 
} 

Answer 4

Perché non utilizzare soluzioni di registrazione esistenti utilizzati da milioni di utenti? log4j, log4net, log4cxx .., per citarne solo alcuni ..

Answer 5

tutto, grazie per la condivisione del codice, ho solo fare una prova, allora il metodo di Neil sarà ancora fare la formattazione di stringa, per esempio:

#include <streambuf> 
#include <ostream> 
#include <iostream> 
using namespace std; 


template <class cT, class traits = std::char_traits<cT> > 
class basic_nullbuf: public std::basic_streambuf<cT, traits> { 
    typename traits::int_type overflow(typename traits::int_type c) 
    { 
     return traits::not_eof(c); // indicate success 
    } 
}; 

template <class cT, class traits = std::char_traits<cT> > 
class basic_onullstream: public std::basic_ostream<cT, traits> { 
    public: 
     basic_onullstream(): 
     std::basic_ios<cT, traits>(&m_sbuf), 
     std::basic_ostream<cT, traits>(&m_sbuf) 
     { 
      init(&m_sbuf); 
     } 

    private: 
     basic_nullbuf<cT, traits> m_sbuf; 
}; 

typedef basic_onullstream<char> onullstream; 
typedef basic_onullstream<wchar_t> wonullstream; 

class MyClass 
{ 
    int a; 
    friend ostream& operator<< (ostream&, MyClass const&); 
}; 

ostream& operator<<(ostream& out,MyClass const& b) 
{ 
    std::cout<<"call format function!!"; 
    out << b.a; 
    return out; 
} 

int main() { 
    onullstream os; 
    MyClass obj; 
    os<<obj; 
} 

l'esecuzione di questo programma, vi accorgerete che "ostream & operatore < < (ostream & fuori, MyClass const & b)" sarà chiamato. Quindi, il formato sull'oggetto verrà comunque chiamato. Quindi, non possiamo ancora evitare il sovraccarico della formattazione dei messaggi.