¿Cuál es una buena práctica para generar resultados detallados?

Question

¿cuál es una buena práctica para generar resultados detallados? Actualmente, tengo una función

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

y siempre que lo desee para generar la salida, hago algo así como

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

embargo

, no creo que eso es muy elegante. entonces me pregunto ¿cuál sería una buena forma de implementar este cambio de verbosidad?

Answer 1

La manera más simple es la creación de pequeña clase de la siguiente manera (en este caso es la versión Unicode, pero se puede cambiar fácilmente a la versión de un solo 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); 
} 

Función de ayuda log se hizo plantilla para obtener sintaxis de llamada agradable. Entonces podría ser utilizado de la siguiente manera:

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; 
} 

Usted podría cambiar el nivel de detalle en tiempo de ejecución mediante el cambio de variable global GLOBAL_LEVEL.

Answer 2

Usted podría utilizar log4cpp

Answer 3

Usted puede envolver su funcionalidad en una clase que soporta el operador < < que le permite hacer algo como

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

A continuación, puede hacer algo como

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. Si usa g ++ puede usar el distintivo -D, esto le permite al compilador definir una macro de su elección.

Definición de la

Por ejemplo:

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

2. Estoy de acuerdo que esto no es elegante, ya sea, por lo que para que sea un poco más agradable:

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*/ 
} 

Que podría utilizar como printf:

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

3. Una tercera solución más fácil, y más C++ y Unix como es pasar un argumento a su programa que se va a usar -como la macro anterior- para inicializar una variable particular (que podría ser un const global)

Ejemplo: $ ./myprogram -v

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