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 design patterns sont des solutions éprouvées et réutilisables à des problèmes courants qui surviennent lors de la conception logicielle. Ce ne sont pas du code que vous copiez 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
Creational	Mécanismes de création d’objets	Singleton, Factory, Builder
Structural	Composition de classes et d’objets	Adapter, Decorator, Composite
Behavioral	Interaction et responsabilités des objets	Observer, Strategy, Command

Pourquoi apprendre les patrons de conception ? Ils fournissent un vocabulaire commun entre les développeurs : dire « utilisez une Factory ici » communique instantanément une idée complexe. Ils vous aident également à éviter de réinventer des solutions et rendent votre code plus flexible et plus facile à maintenir.

En C++, les patrons de conception s’appuient sur les fonctionnalités de la POO que vous avez déjà apprises : l’héritage, le polymorphisme, les classes abstraites et les modèles. Au cours des prochaines leçons, vous implémenterez plusieurs patrons essentiels et comprendrez dans quels cas chacun d’eux est l’outil approprié.

Défi

Facile

Construisons un classificateur de patrons simple qui démontre ta compréhension des trois catégories de patrons de conception. Tu vas créer un système qui prend le nom d’un patron et identifie la catégorie à laquelle il appartient — Créationnelle, Structurelle ou Comportementale — accompagné d’une brève description de l’objectif de cette catégorie.

Tu organiseras ton code sur trois fichiers :

PatternCategory.h : définis une classe de base abstraite appelée PatternCategory qui représente une catégorie de patrons de conception. Elle doit comporter :
- Une méthode virtuelle pure getName() qui renvoie le nom de la catégorie sous forme de chaîne
- Une méthode virtuelle pure getPurpose() qui renvoie une description de ce que font les patrons de cette catégorie
- Un destructeur virtuel
Crée 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ée une classe PatternClassifier capable d’identifier la catégorie à laquelle appartient un patron donné.
Ton classificateur doit posséder une méthode classify qui accepte le nom d’un patron (une chaîne) et renvoie un pointeur vers le PatternCategory approprié. Utilise des pointeurs intelligents (std::unique_ptr) pour la gestion de la mémoire.

Le classificateur doit reconnaître les patrons suivants :
- Créationnels : Singleton, Factory, Builder
- Structurels : Adapter, Decorator, Composite
- Comportementaux : Observer, Strategy, Command
Si le nom du patron n’est pas reconnu, renvoie nullptr.
main.cpp : lis une seule entrée : le nom d’un patron de conception.
Crée un PatternClassifier et utilise-le pour classifier le patron saisi. Si le patron est reconnu, affiche :
```
[PatternName] is a [CategoryName] pattern
Purpose: [CategoryPurpose]
```
Si le patron n’est pas reconnu, affiche :
```
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 les trois catégories de patrons de conception tout en permettant de pratiquer l’héritage, le polymorphisme et les pointeurs intelligents : tous des concepts que tu maîtrises déjà. La structure en plusieurs fichiers reflète la manière 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 classifieur pour classifier le pattern en entrée
    
    // 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;
}