> Comprenez et implémentez le pattern Factory en C++ : principe, code commenté, factory method vs abstract factory, et quand l'utiliser (ou non).

*Source : https://coder-studio.com/tutoriels/design-pattern-factory-cpp/*

---

[// C / C++](https://coder-studio.com/tutoriels/)

# Le design pattern Factory en C++

Par **Kévin Papot** · publié le 2 juin 2026

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++](https://coder-studio.com/tutoriels/design-pattern-observer-cpp/) pour la gestion d’événements, et notre guide sur [la gestion des ressources avec RAII](https://coder-studio.com/tutoriels/raii-cpp/) pour ne jamais fuir de mémoire. Débutant ? Commencez par [les bases du langage C](https://coder-studio.com/tutoriels/langage-c/).