Journalisation en C++ : meilleures pratiques pour débutants

Journalisation dans les applications C++ : meilleures pratiques pour débutants

La journalisation (enregistrement) est le processus de consignation des événements qui se produisent pendant l'exécution d'un programme. Pour un développeur C++ débutant, savoir organiser correctement la journalisation n'est pas simplement une « bonne pratique », mais une compétence cruciale. Elle aide à déboguer le code, à suivre les erreurs en production et à analyser le comportement du système. Dans cet article, nous allons examiner les meilleures pratiques de journalisation en C++, des méthodes les plus simples à l'utilisation de bibliothèques modernes, avec des exemples de code concrets.

Pourquoi l'utilisation simple de std::cout est-elle une mauvaise pratique ?

De nombreux débutants commencent par afficher des messages de débogage via std::cout ou printf. C'est rapide et simple, mais cette approche présente de sérieux inconvénients :

• Absence de niveaux d'importance. Impossible de distinguer les messages d'erreur des notifications informatives.
• Difficulté de filtrage. En production, vous ne voulez pas voir des tonnes de messages de débogage, alors qu'en débogage ils sont nécessaires.
• Pas de rotation des fichiers. Le fichier de log va croître indéfiniment jusqu'à remplir tout le disque.
• Problèmes de multithreading. Les sorties de différents threads peuvent se mélanger.

Au lieu de cela, il faut utiliser des outils spécialisés. Examinons trois approches principales : de la plus simple à la plus complexe.

1. Simple enveloppe macro pour débutants

Si vous écrivez un petit programme d'apprentissage ou ne souhaitez pas inclure de bibliothèques externes, vous pouvez créer une simple enveloppe avec des macros. C'est déjà mieux qu'un cout nu.

#include <iostream>#include <fstream>#include <ctime>#include <string>

enum LogLevel {    DEBUG,    INFO,    WARNING,    ERROR};

std::string getCurrentTime() {    std::time_t now = std::time(nullptr);    char buf[20];    std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", std::localtime(&now));    return std::string(buf);}

#define LOG(level, msg) \    do { \        std::ofstream logFile("app.log", std::ios::app); \        logFile << "[" << getCurrentTime() << "] " \                << "[" << #level << "] " \                << msg << std::endl; \    } while(0)

int main() {    LOG(INFO, "Programme démarré");    int x = 42;    LOG(DEBUG, "Valeur de x : " << x);    // ...    LOG(ERROR, "Erreur de division par zéro");    return 0;}

Avantages : simplicité, aucune dépendance externe.

Inconvénients : pas de rotation, fonctionnement lent (ouverture/fermeture du fichier pour chaque message), problèmes de threads.

2. Utilisation de la bibliothèque spdlog (recommandée pour les débutants)

spdlog est la bibliothèque de journalisation la plus populaire en C++ (plus de 23 000 étoiles sur GitHub). Elle est très rapide, simple à utiliser et header-only (fichiers d'en-tête uniquement).

Installation : téléchargez simplement les fichiers depuis le dépôt ou utilisez vcpkg/conan.

#include <spdlog/spdlog.h>#include <spdlog/sinks/basic_file_sink.h>#include <spdlog/sinks/stdout_color_sinks.h>

int main() {    // Création d'un logger console avec sortie colorée    auto console = spdlog::stdout_color_mt("console");        // Création d'un logger fichier    auto file_logger = spdlog::basic_logger_mt("file_logger", "logs/app.log");        // Définition du niveau de journalisation    spdlog::set_level(spdlog::level::debug); // Journaliser tout à partir de DEBUG et au-dessus        // Exemples de messages de différents niveaux    console->trace("Ceci est un message trace (niveau le plus bas)");    console->debug("Message de débogage : variable x = {}", 42);    console->info("Programme démarré avec succès");    console->warn("P