Le design pattern Factory en C++

Le pattern Factory (fabrique) fait partie des tout premiers design patterns qu’un développeur C++ rencontre — et pour cause : il répond à un besoin universel, créer des objets sans coder en dur la classe concrète instanciée. Ce tutoriel reprend et modernise l’un des articles historiques de Coder Studio, avec un code conforme au C++ actuel.

Le problème que résout la Factory

Imaginez un jeu où vous devez créer des ennemis. Une approche naïve dissémine des new Zombie(), new Orc() partout dans le code. Le jour où vous ajoutez un type d’ennemi, vous devez retrouver et modifier chaque endroit. C’est fragile et cela viole le principe Open/Closed (ouvert à l’extension, fermé à la modification).

La Factory centralise la création derrière une interface unique. Le code appelant demande « un ennemi de type X » sans jamais connaître la classe concrète.

Factory Method : l’implémentation de base

#include <memory>
#include <string>

class Ennemi {
public:
    virtual std::string attaquer() const = 0;
    virtual ~Ennemi() = default;
};

class Zombie : public Ennemi {
public:
    std::string attaquer() const override { return "Grrr..."; }
};

class Orc : public Ennemi {
public:
    std::string attaquer() const override { return "Pour la horde !"; }
};

enum class TypeEnnemi { Zombie, Orc };

std::unique_ptr<Ennemi> creerEnnemi(TypeEnnemi type) {
    switch (type) {
        case TypeEnnemi::Zombie: return std::make_unique<Zombie>();
        case TypeEnnemi::Orc:    return std::make_unique<Orc>();
    }
    return nullptr;
}

Le code client devient limpide et découplé :

auto ennemi = creerEnnemi(TypeEnnemi::Orc);
std::cout << ennemi->attaquer() << "\n";  // "Pour la horde !"

Notez l’usage de std::unique_ptr et std::make_unique : la fabrique retourne un pointeur intelligent, ce qui garantit la libération automatique de la mémoire. C’est le C++ moderne — on ne rend plus de pointeurs nus.

Abstract Factory : quand on fabrique des familles d’objets

La variante Abstract Factory pousse le concept plus loin : au lieu d’un seul produit, elle crée des familles cohérentes. Exemple classique : une interface graphique qui doit produire boutons, menus et fenêtres soit en thème « sombre », soit en thème « clair ». Chaque fabrique concrète (FabriqueSombre, FabriqueClaire) garantit que tous les composants sont visuellement cohérents entre eux.

Quand (ne pas) utiliser la Factory

La Factory brille quand le type concret dépend d’une donnée d’exécution (configuration, entrée utilisateur, format de fichier). En revanche, ne l’introduisez pas par réflexe : si vous n’avez qu’une seule implémentation et aucune perspective d’extension, un simple constructeur suffit. Le sur-usage des patterns est une forme de complexité gratuite — le pattern doit résoudre un problème réel, pas décorer le code.

---

La Factory se marie souvent avec d’autres patterns : découvrez le pattern Observer en C++ pour la gestion d’événements, et notre guide sur la gestion des ressources avec RAII pour ne jamais fuir de mémoire. Débutant ? Commencez par les bases du langage C.