Récapitulatif : Logger Factory

Fait partie de la section Programmation Orientée Objet du Journey C de Coddy. Leçon 57 sur 61.

Défi

Facile

Construisons une fabrique de journalisation : un système qui démontre la puissance de la combinaison du patron Factory avec le polymorphisme. Votre fabrique créera différentes implémentations de journalisation en fonction d’un indicateur de configuration, permettant au code de basculer entre une sortie console détaillée et une journalisation silencieuse avec un « dummy », sans modifier la manière dont les journaliseurs sont utilisés.

Vous organiserez votre code dans trois fichiers :

logger.h : définissez une structure Logger qui sert d’interface. Elle doit contenir un pointeur de fonction pour log qui prend un Logger* et un message const char*. Déclarez votre fonction de fabrique create_logger, qui prend un indicateur entier (1 pour la console, 0 pour le dummy) et renvoie un Logger*. Déclarez également une fonction free_logger pour le nettoyage.
logger.c : implémentez deux types concrets de journaliseurs. Le ConsoleLogger intègre Logger comme premier membre et possède une fonction de journalisation qui affiche les messages au format [LOG] message. Le DummyLogger intègre également Logger, mais sa fonction de journalisation ne fait rien. Elle retourne simplement sans rien afficher. Créez des fonctions constructrices pour chaque type, qui allouent de la mémoire et configurent le pointeur vers la fonction de journalisation appropriée. Implémentez ensuite create_logger comme une fabrique qui vérifie l’indicateur et renvoie le type de journaliseur approprié sous forme de Logger*. Implémentez free_logger pour libérer la mémoire.
main.c : lisez un entier (1 ou 0) pour déterminer quel journaliseur créer. Utilisez votre fabrique pour créer le journaliseur approprié, puis appelez sa fonction log avec deux messages : "Starting application" et "Shutting down". Enfin, libérez le journaliseur.

Votre programme recevra une entrée : un entier indiquant le type de journaliseur (1 pour la console, 0 pour le dummy).

Exemple de sortie lorsque l’entrée est 1 :

[LOG] Starting application
[LOG] Shutting down

Exemple de sortie lorsque l’entrée est 0 :

(Aucune sortie : le journaliseur dummy ignore silencieusement tous les messages.)

L’élégance de cette approche réside dans le fait que main.c utilise le journaliseur de manière identique, quel que soit le type qu’il reçoit. La fabrique décide de ce qui doit être créé, et le polymorphisme garantit que le comportement correct est exécuté. Ce patron est extrêmement utile dans les applications réelles, lorsque vous souhaitez une journalisation détaillée pendant le développement, mais un fonctionnement silencieux en production.

Essayez vous-même

#include <stdio.h>
#include "logger.h"

int main() {
    // Lire le flag de type de logger (1 pour console, 0 pour dummy)
    int flag;
    scanf("%d", &flag);
    
    // TODO: Utiliser la factory pour créer le logger approprié
    
    // TODO: Call the logger's log function with "Starting application"
    
    // TODO: Call the logger's log function with "Shutting down"
    
    // TODO: Libérer le logger
    
    return 0;
}