Rediriger C++ fstream

Question

J'ai donc un programme C++, qui normalement lors de l'exécution écrit des choses dans un fichier journal. Ceci est fait en utilisant un fstream. Cependant, maintenant je veux inclure des fonctionnalités pour désactiver la journalisation. Essentiellement, mon code ressemble à ceci:

bool isLogging; 
fstream* logFilePtr; 

tout au long de mon code, il y a un tas de déclarations comme:

(*logFilePtr) << " Kernel call time in seconds: " << kTime << endl; 
... 

Maintenant, si le « isLogging » est vrai, je ne veux pas que ces imprimer. Je pourrais juste les entourer d'un tas de déclarations if, mais je préférerais quelque chose de plus propre que ça. Je pensais qu'il y avait un moyen de prendre un flux C++ et de le rediriger vers "rien" de sorte que lorsque l'opérateur < < est utilisé, rien ne s'imprime.

Est-ce que quelqu'un sait comment rediriger le flux, ou avez d'autres idées sur la façon de gérer cela de façon élégante?

Merci, Colin

Answer 1

Vous pourriez l'envelopper dans une classe.

class Log { 
    Log (fstream &s) : stream(s), enabled(false) { } 
    void Enable() { enabled = true; } 
    void Disable() { enabled = false; } 

    template<class T> 
    Log &operator<< (T const& rhs) { 
    if (enabled) stream << rhs; 
    return *this; 
    } 

private: 
    fstream &stream; 
    bool enabled; 
}; 

Ceci n'est pas testé ... mais l'idée de base devrait être là.

Answer 2

plateforme? Si vous êtes sous unix, vous pouvez écrire le fichier dans/dev/null

Answer 3

J'utilise la fonction de journalisation de la bibliothèque POCO. Il supporte la configuration des canaux - console, fichier, les deux. Configuration du format des niveaux de sortie et de journalisation (trace, débogage, erreur, etc.). Je puis entourer la fonctionnalité d'enregistrement avec des fonctions telles que

inline void logError(const std::string & str) 
{ 
#ifdef COMPILE_ERROR_LOGGING 
    g_pMyPocoLogger->error(str); 
#endif 
} 

Vous pouvez choisir de ne pas utiliser la bibliothèque, mais je recommande toujours autour de votre exploitation forestière avec une enveloppe.

Answer 4

Jetez un oeil à rdbuf member function. Vous pouvez créer un tampon de flux ignoré et l'associer à votre flux.

struct nullbuf: std::streambuf 
{ 
    int overflow(int c) { return traits_type::not_eof(c); } 
}; 

Answer 5

std :: iostream ne permet pas la redirection niveau du système d'exploitation, cependant, vous pouvez partager std :: streambufs entre std :: iostreams:

int main() { 
    // redirect stdout to stderr: 
    std::streambuf * const oldstdout = std::cout.rdbuf(); 
    std::cout.rdbuf(std::cerr.rdbuf()); 

    // test 
    std::cout << "Hello "; 
    std::cerr << "World" << std::endl; 

    // re-set, so streambufs are properly deleted: 
    std::cout.rdbuf(oldstdout); 

    // test 
    std::cout << "Hello "; 
    std::cerr << "World" << std::endl; 

    return 0; 
} 

De cette façon, vous pouvez rediriger l'exploitation forestière à ailleurs (par exemple "/ dev/null" :), ou, si vous suivez la réponse d'avakar, utilisez nullbuf.

Answer 6

std::ostream& Debug(int level) { 
    std::clog.clear(levell <= shown_level ? std::ios_base::goodbit: std::ios_base::badbit); 
    return std::clog; 
} 

De comp.lang.c++.

Answer 7

Sous la rubrique « autres idées sur la façon de gérer cette »:

1. Utilisez le modèle d'état afin d'éliminer la nécessité pour les contrôles si autour de tout le code.
2. Utilisez le modèle de stratégie (modèle de stratégie de compilation) avec un objet de stratégie Journalisation.