Che cosa è una buona pratica per generare un output dettagliato?

Question

qual è la buona pratica per generare un output dettagliato? Attualmente, ho una funzione

bool verbose; 
int setVerbose(bool v) 
{ 
    errormsg = ""; 
    verbose = v; 
    if (verbose == v) 
     return 0; 
    else 
     return -1; 
} 

e ogni volta che voglio generare output, faccio qualcosa di simile

if (debug) 
    std::cout << "deleting interp" << std::endl; 

tuttavia, non credo che sia molto elegante. quindi mi chiedo quale sarebbe un buon modo per implementare questo switch di verbosità?

Answer 1

Il modo più semplice è quello di creare piccola classe come segue (qui è la versione Unicode, ma si può facilmente cambiare alla versione a singolo byte):

#include <sstream> 
#include <boost/format.hpp> 
#include <iostream> 
using namespace std; 

enum log_level_t { 
    LOG_NOTHING, 
    LOG_CRITICAL, 
    LOG_ERROR, 
    LOG_WARNING, 
    LOG_INFO, 
    LOG_DEBUG 
}; 

namespace log_impl { 
class formatted_log_t { 
public: 
    formatted_log_t(log_level_t level, const wchar_t* msg) : fmt(msg), level(level) {} 
    ~formatted_log_t() { 
     // GLOBAL_LEVEL is a global variable and could be changed at runtime 
     // Any customization could be here 
     if (level <= GLOBAL_LEVEL) wcout << level << L" " << fmt << endl; 
    }   
    template <typename T> 
    formatted_log_t& operator %(T value) { 
     fmt % value; 
     return *this; 
    }  
protected: 
    log_level_t  level; 
    boost::wformat  fmt; 
}; 
}//namespace log_impl 
// Helper function. Class formatted_log_t will not be used directly. 
template <log_level_t level> 
log_impl::formatted_log_t log(const wchar_t* msg) { 
    return log_impl::formatted_log_t(level, msg); 
} 

funzione Helper log è stata fatta template per ottenere sintassi di chiamata bello. Quindi potrebbe essere utilizzato nel modo seguente:

int main() 
{ 
    // Log level is clearly separated from the log message 
    log<LOG_DEBUG>(L"TEST %3% %2% %1%") % 5 % 10 % L"privet"; 
    return 0; 
} 

si potrebbe cambiare livello di dettaglio in fase di esecuzione, cambiando variabile globale GLOBAL_LEVEL.

Answer 2

Si potrebbe utilizzare log4cpp

Answer 3

si può avvolgere la funzionalità in una classe che supporta il < < operatore, che ti permette di fare qualcosa di simile

class Trace { 
    public: 
     enum { Enable, Disable } state; 
    // ... 
    operator<<(...) 
}; 

Poi si può fare qualcosa di simile

trace << Trace::Enable; 
trace << "deleting interp" 

Answer 4

enum LogLevel 
{ 
    INF = 0, 
    WAR = 1, 
    ERR = 2 
}; 

LogLevel threshold = WAR; 

class mystreambuf: public std::streambuf {}; 
mystreambuf nostreambuf; 
std::ostream nocout(&nostreambuf); 
#define log(x) ((x >= threshold)? std::cout : nocout) 

int main() 
{ 
    log(INF) << "No hello?" << std::endl;  // Not printed on console, too low log level. 
    log(ERR) << "Hello world!" << std::endl; // Will print. 
    return 0; 
} 

Answer 5

1. Se si utilizza g ++ è possibile utilizzare il flag -D, ciò consente al compilatore di definire una macro di propria scelta.

Definizione del

Per esempio:

#ifdef DEBUG_FLAG 
printf("My error message"); 
#endif 

2. Sono d'accordo che non è elegante o, in modo per renderlo un po 'più bello:

void verbose(const char * fmt, ...) 
{ 
va_list args; /* Used as a pointer to the next variable argument. */ 
va_start(args, fmt); /* Initialize the pointer to arguments. */ 

#ifdef DEBUG_FLAG 
printf(fmt, &args); 
#endif 
/*This isn't tested, the point is to be able to pass args to 
printf*/ 
} 

Che potrebbe utilizzare come printf:

verbose("Error number %d\n",errorno); 

3. Una terza soluzione più semplice e più simile a C++ e Unix è passare un argomento al programma che verrà utilizzato, come la macro in precedenza, per inizializzare una variabile particolare (che potrebbe essere un const globale).

Esempio: $ ./myprogram -v

if(optarg('v')) static const verbose = 1;