Quelle est la bonne pratique pour générer une sortie verbeuse?

Question

Quelle est la bonne pratique pour générer une sortie verbeuse? actuellement, j'ai une fonction

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

et chaque fois que je veux générer une sortie, je fais quelque chose comme

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

cependant, je ne pense pas que ce soit très élégant. donc je me demande ce qui serait un bon moyen de mettre en œuvre ce changement de verbosité?

Answer 1

La manière la plus simple est de créer petite classe comme suit (ici est une version Unicode, mais vous pouvez facilement changer en version mono-octet):

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

fonction d'aide log a été modèle pour obtenir belle syntaxe d'appel. Ensuite, il pourrait être utilisé de la manière suivante:

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

Vous pouvez modifier le niveau de verbosité lors de l'exécution en changeant la variable globale GLOBAL_LEVEL.

Answer 2

Vous pouvez utiliser log4cpp

Answer 3

Vous pouvez envelopper votre fonctionnalité dans une classe qui prend en charge l'opérateur < < qui vous permet de faire quelque chose comme

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

Ensuite, vous pouvez faire quelque chose comme

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 vous utilisez g ++, vous pouvez utiliser l'option -D, cela permet au compilateur de définir une macro de votre choix.

Définition du

Par exemple:

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

2. Je suis d'accord ce n'est pas élégant non plus, donc pour le rendre un peu plus agréable:

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 vous pourrait utiliser comme printf:

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

3. Une troisième solution plus facile, et plus C++ et Unix like est de passer un argument à votre programme qui va être utilisé - comme la macro plus tôt - pour initialiser une variable particulière (qui pourrait être un const).

Exemple: ./myprogram $ -v

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