Quelles sont les bonnes pratiques pour générer une sortie détaillée?

ce qui est une bonne pratique pour générer une sortie détaillée? 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 la sortie, je fais quelque chose comme

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

cependant, je ne pense pas que c'est très élégant. donc, je me demande ce que ce serait une bonne façon de mettre en œuvre cette verbosité switch?

Doesnt votre setVerbose retourne toujours 0?
oui, à moins que quelque chose de très ésotérique qui se passe. c'est juste que j'ai un tas de setSomething() les fonctions qui tout retourne 0 si l'opération a été un succès et -1 sinon. donc, c'est juste une question d'avoir une interface cohérente ...
Je ne comprends pas ce code. Est-ce un cas de l'édition qui a mal tourné?

OriginalL'auteur andreas-h | 2009-08-10

  1. 10

    La façon la plus simple est de créer de la petite classe comme suit(ici est la version Unicode, mais vous pouvez facilement le remplacer par un octet version):

    #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'assistance log a été faite de modèle pour obtenir de belles 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 changer de niveau de verbosité à l'exécution par l'évolution mondiale GLOBAL_LEVEL variable.

    j'aime cette réponse. j'ai vraiment besoin de ce très simple stdout enregistrement, aucune de fichiers/d'autres choses réseau de besoin (je l'espère). donc je vais essayer de garder le nombre de dépendances externes bas et aller faire ma propre mise en œuvre.
    Je trouve cette solution intelligente et très utile, je le souhaite, je peux lui donner 10 upvotes! 🙂
    Je crois que le GLOBAL_LEVEL variable sera problématique à travers les unités de traduction, ai-je le droit? Comment voulez-vous mettre en œuvre cette variable?

    OriginalL'auteur Kirill V. Lyadvinsky

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

int main()
{
    log(1) << "No hello?" << std::endl;     //Not printed on console, too low log level.
    log(5) << "Hello world!" << std::endl;  //Will print.
    return 0;
}
    y aurait-il une possibilité de "include" le std::endl dans le journal (le) de la définition?
    Définir log(x) peut être facilement remplacé par fonction en ligne. Est-il nécessaire d'utiliser définit ici?
    Concernant std::endl: aucun, que je sache. Si vous voulez moins de code, vous pouvez toujours utiliser typedef, comme _e. Regardig #define/en ligne: pas de raison.

    OriginalL'auteur Jonas Byström

  3. 3

    Vous pouvez utiliser log4cpp

    Est-ce que c'asynchrone des fonctionnalités de journalisation?
    Je ne sais pas si c'est le cas ou non. désolé.
    Je suis d'accord que l'utilisation d'une bonne bibliothèque de journalisation est la réponse plutôt qu'à la main-codage quelque chose, même si Log4cpp semble être moribond. logging.apache.org/log4cxx/index.html d'autre part, est bien vivante. Selon le site web, il n'a pas le support pour asynchrones journalisation, bien que je ne pense pas que ce soit pertinent pour cette question.
    +1 pour ce qui suggère log4cxx, je l'avais oublié celui-là.
    Ou log4cplus.

    OriginalL'auteur Glen

  4. 3

    Vous pouvez envelopper votre fonctionnalité dans une classe qui prend en charge la << opérateur qui 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"
    J'aime l'idée d'envelopper une erreur d'enregistrement de système dans une classe. Vous pouvez stocker des choses comme l'emplacement du fichier de sortie et autres joyeusetés dans la classe, trop.
    juste si je vous comprends bien: je voudrais créer une instance de la classe Trace appelé trace avant? et puis une autre question: pourquoi est-Trace::Activer assez pour mettre de l'état afin de Permettre? je suis encore assez novice en c++, et je suis un peu confus. peut-être certains trois lignes dans votre idée pourrait m'aider à mieux comprendre ce qu'il se passe. mais j'aime ton idée!
    Oui, vous devez créer une instance de la classe Trace; ce pourrait être statique ou localement à chaque composant qui souhaite l'utiliser. La Trace::Activer ferait basculer un indicateur interne au sein de la classe Trace (une instance de l'état enum). Ce serait très bien comme std::hex permet std::cout de la sortie au format hex, au lieu de la virgule. Puisque vous allez être écrit de l'opérateur<< vous pouvez prendre en charge de Trace::Activer (ou tout autre état de prescripteurs tels que le niveau de verbosité et tel)
    Andreash, Trace::Enable serait suffisant pour définir l'état de Enable parce que vous allez écrire du code pour le << opérateur qui rend votre classe de savoir comment gérer ce drapeau. Il n'y a pas de magie ici. Personnellement, je voudrais faire un membre ordinaire de la fonction et de dire trace.enable().

    OriginalL'auteur ezpz

  5. 3

    1. Si vous êtes à l'aide de g++, vous pouvez utiliser le flag-D, cela permet au compilateur de définir une macro de votre choix.

    La définition de la

    Par exemple :

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

    2. Je suis d'accord ce n'est pas élégant, afin de 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 pouvez utiliser comme printf :

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

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

    Exemple :
    $ ./myprogram -v

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

    OriginalL'auteur MSI