Introduction aux modèles de conception

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 90 sur 104.

Les patrons de conception sont des solutions éprouvées et réutilisables à des problèmes courants qui surviennent lors de la conception logicielle. Ce n’est pas du code que l’on copie directement : ce sont des modèles ou des schémas qui décrivent comment structurer les classes et les objets pour résoudre élégamment des problèmes spécifiques.

Le concept a été popularisé par le « Gang of Four » (GoF) dans leur livre de 1994, qui répertoriait 23 modèles fondamentaux. Ces modèles sont généralement regroupés en trois catégories :

Catégorie	Objectif	Exemples
Création	Mécanismes de création d’objets	Singleton, Factory, Builder
Structure	Composition de classes et d’objets	Adapter, Decorator, Composite
Comportement	Interaction et responsabilité des objets	Observer, Strategy, Command

Pourquoi apprendre les modèles de conception ? Ils fournissent un vocabulaire commun aux développeurs : dire « utilise une fabrique ici » communique instantanément une idée complexe. Ils t’aident également à éviter de réinventer des solutions et rendent ton code plus flexible et plus facile à maintenir.

En C++, les patrons de conception tirent parti des fonctionnalités de la POO que tu as déjà apprises : l’héritage, le polymorphisme, les classes abstraites et les modèles. Dans les prochaines leçons, tu mettras en œuvre plusieurs patrons essentiels et tu comprendras dans quels cas chacun est l’outil adapté.

Défi

Facile

Construisons un classificateur de patrons simple qui démontre votre compréhension des trois catégories de patrons de conception. Vous allez créer un système qui prend un nom de patron et détermine à quelle catégorie il appartient, Créationnelle, Structurelle ou Comportementale, ainsi qu'une brève description de l'objectif de cette catégorie.

Vous organiserez votre code dans trois fichiers :

PatternCategory.h : définissez une classe de base abstraite appelée PatternCategory qui représente une catégorie de patrons de conception. Elle doit avoir :
- Une méthode virtuelle pure getName() qui renvoie le nom de la catégorie sous forme de chaîne de caractères
- Une méthode virtuelle pure getPurpose() qui renvoie une description de ce que font les patrons de cette catégorie
- Un destructeur virtuel
Créez ensuite trois classes dérivées qui héritent de PatternCategory :
- CreationalCategory : renvoie le nom "Creational" et l'objectif "Object creation mechanisms"
- StructuralCategory : renvoie le nom "Structural" et l'objectif "Class and object composition"
- BehavioralCategory : renvoie le nom "Behavioral" et l'objectif "Object interaction and responsibility"
PatternClassifier.h : créez une classe PatternClassifier capable de déterminer à quelle catégorie appartient un patron donné.
Votre classificateur doit avoir une méthode classify qui prend un nom de patron (chaîne de caractères) et renvoie un pointeur vers le PatternCategory approprié. Utilisez des pointeurs intelligents (std::unique_ptr) pour la gestion de la mémoire.

Le classificateur doit reconnaître les patrons suivants :
- Créationnelle : Singleton, Factory, Builder
- Structurelle : Adapter, Decorator, Composite
- Comportementale : Observer, Strategy, Command
Si le nom du patron n'est pas reconnu, renvoyez nullptr.
main.cpp : lisez une seule entrée : le nom d'un patron de conception.
Créez un PatternClassifier et utilisez-le pour classer le patron saisi. Si le patron est reconnu, affichez :
```
[PatternName] is a [CategoryName] pattern
Purpose: [CategoryPurpose]
```
Si le patron n'est pas reconnu, affichez :
```
Unknown pattern: [PatternName]
```

Par exemple, avec l'entrée Singleton :

Singleton is a Creational pattern
Purpose: Object creation mechanisms

Avec l'entrée Observer :

Observer is a Behavioral pattern
Purpose: Object interaction and responsibility

Avec l'entrée Proxy :

Unknown pattern: Proxy

Ce défi renforce votre connaissance des trois catégories de patrons de conception tout en vous faisant pratiquer l'héritage, le polymorphisme et les pointeurs intelligents : autant de concepts que vous maîtrisez déjà. La structure en plusieurs fichiers reflète la façon dont les projets réels organisent les classes associées.

Essayez vous-même

#include <iostream>
#include <string>
#include "PatternClassifier.h"

int main() {
    // Lire le nom du pattern
    std::string patternName;
    std::cin >> patternName;
    
    // TODO: Créer une instance de PatternClassifier
    
    // TODO: Utiliser le classificateur pour classer le pattern saisi
    
    // TODO: Si le pattern est reconnu, afficher :
    // "[PatternName] is a [CategoryName] pattern"
    // "Purpose: [CategoryPurpose]"
    
    // TODO: Si le pattern n’est pas reconnu (nullptr), afficher :
    // "Unknown pattern: [PatternName]"
    
    return 0;
}