Co to jest dobra praktyka do generowania szczegółowych wyników?

Question

jaka jest dobra praktyka do generowania szczegółowych wyników? Obecnie mam funkcję

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

i kiedy chcę, aby wygenerować dane wyjściowe, zrobić coś podobnego

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

Jednak nie sądzę, że to bardzo elegancki. więc zastanawiam się, jaki byłby dobry sposób na wprowadzenie tego przełącznika gadatliwości?

Answer 1

Najprostszy sposób jest stworzenie małej klasy jak następuje (tu jest wersja Unicode, ale łatwo można go zmienić do wersji single-bajtowy):

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

Helper funkcja log powstał szablon, aby uzyskać ładny składnię wywołania. Może to być używane w następujący sposób:

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

Można zmienić poziom oznajmiania w czasie wykonywania przez zmianę globalną GLOBAL_LEVEL zmienną.

Answer 2

Można użyć log4cpp

Answer 3

Można owinąć funkcjonalność w klasie, który obsługuje operator < < który pozwala zrobić coś jak

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

Następnie można zrobić coś takiego

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. Jeśli używasz g ++, możesz użyć opcji -D, co pozwala kompilatorowi zdefiniować wybrane makro.

Definiowanie

Na przykład:

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

2. Zgadzam to nie jest eleganckie albo, tak aby uczynić go nieco ładniejszy:

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

Że może używać jak printf:

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

3. Trzecie rozwiązanie łatwiejsze, a bardziej C++ i Unix jak przekazać argument do twojego programu, który ma być użyty - jak makro wcześniej - do zainicjowania konkretnej zmiennej (która może być globalną).

Przykład: $ ./myprogram -v

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