Come rimuovere le dichiarazioni di debug del log da un programma

Question

Sto usando boost::log come un logger per il mio programma C++. Durante lo sviluppo Io uso spesso in questo modo, ad esempio:

#define LOG(severity) BOOST_LOG_SEV(boost::logger::get(), (severity)) 
#define LOG_ERR LOG(Severity::error) 
#define LOG_INFO LOG(Severity::info) 
#define LOG_DEBUG LOG(Severity::debug) 

dove BOOST_LOG_SEV è lo strumento fornito dal boost::log, mentre LOG, LOG_ERROR, LOG_INFO, LOG_DEBUG sono scorciatoie definite da me.

In breve, BOOST_LOG_SEV confronta dinamicamente la severità di debug corrente con la gravità passata alla macro stessa per decidere se emettere o meno l'output.

Questo è un esempio di un programma che utilizza le macro di cui sopra per scopi di debug:

// set at compile time 
#define MAX_LOG_SEVERITY Severity::debug 

int main() { 
    // Print all the messages with a 
    // Severity <= MAX_LOG_SEVERITY defined before compiling 
    boost::log::set_severity(boost::logger::get(), MAX_LOG_SEVERITY); // set_severity() is fictitious just to give you an idea 

    // bool err = ... 
    if (err) 
     LOG_ERR << "An error occurred"; 
    else 
     LOG_INFO << "Okay; 
    LOG_DEBUG << "main() called"; 
} 

Ora, quando si rilascia il programma per un ambiente di produzione, i messaggi di debug con un livello Severity::debug in realtà non ha senso. Potrei nasconderli dall'output semplicemente diminuendo MAX_LOG_SEVERITY a Severity::info, ma il problema è che le chiamate effettuate da LOG_DEBUG non verranno rimosse dal codice eseguibile. Ciò ha un impatto negativo sull'efficienza e sulla dimensione dell'oggetto.

Il codice è pieno di dichiarazioni di registrazione e mi piacerebbe davvero conservare il semplice utilizzo di operator<<().

Senza toccare tali dichiarazioni stessi, c'è qualche migliore definizione macro/trucco per LOG_DEBUG che renderebbe il pre-processore o il compilatore (durante i suoi ottimizzazioni) "saltare" o "rimuovere" le indicazioni di debug quando MAX_LOG_SEVERITY è impostato la costante Severity::debug?

Answer 1

Mentre non posso fare alcuna garanzia, una cosa del genere potrebbe funzionare. Dipende da cosa fa il tuo ottimizzatore e se hai o meno effetti collaterali nei parametri per l'operatore < <.

#ifdef NO_LOG_DEBUG 

static class DevNull 
{ 
} dev_null; 

template <typename T> 
DevNull & operator<<(DevNull & dest, T) 
{ 
    return dest; 
} 

#define LOG_DEBUG dev_null 

#else 

#define LOG_DEBUG LOG(Severity::debug) 

#endif 

Answer 2

Disattiva tutte le ottimizzazioni nel programma e velocizza la compilazione.

/od o boot_log_stop

Answer 3

@ risposta accettato di MartinShobe lavora su:

• g ++ (4.7.2) con -O1 e superiori
• clang ++ (3.4) con -O2 e superiori
• Visual Studio (2008) con linker flag /OPT:REF