Patrons de conception en C++ : techniques avancées et exemples

Patrons de conception avancés en C++ : de la théorie aux implémentations complexes

Les patrons de conception sont des solutions éprouvées aux problèmes typiques qui surviennent lors du développement de logiciels. Si les patrons de base (Singleton, Factory, Observer) sont connus de tout développeur, les techniques avancées nécessitent une compréhension approfondie du langage C++, de ses templates, de l'héritage multiple et de la métaprogrammation. Dans cet article, nous allons analyser quatre patrons puissants : Visitor, Strategy, State et CRTP — avec des exemples de code réels et des explications sur quand les utiliser.

1. Patron Visitor (Visiteur) — extension des fonctionnalités sans modifier les classes

Le patron Visitor permet d'ajouter de nouvelles opérations à une hiérarchie de classes sans modifier les classes elles-mêmes. Cela est particulièrement utile lorsque vous avez une structure d'objets stable, mais des algorithmes de traitement qui changent fréquemment.

Exemple : traitement de formes géométriques

#include <iostream>\n#include <vector>\n#include <memory>\n\n// Forward declaration\nclass Circle;\nclass Rectangle;\n\n// Visiteur abstrait\nclass Visitor {\npublic:\n    virtual void visit(Circle& circle) = 0;\n    virtual void visit(Rectangle& rectangle) = 0;\n    virtual ~Visitor() = default;\n};\n\n// Élément abstrait\nclass Shape {\npublic:\n    virtual void accept(Visitor& visitor) = 0;\n    virtual ~Shape() = default;\n};\n\n// Éléments concrets\nclass Circle : public Shape {\npublic:\n    double radius;\n    explicit Circle(double r) : radius(r) {}\n    void accept(Visitor& visitor) override {\n        visitor.visit(*this);\n    }\n};\n\nclass Rectangle : public Shape {\npublic:\n    double width, height;\n    Rectangle(double w, double h) : width(w), height(h) {}\n    void accept(Visitor& visitor) override {\n        visitor.visit(*this);\n    }\n};\n\n// Visiteur concret — calcul de la surface\nclass AreaVisitor : public Visitor {\npublic:\n    double totalArea = 0.0;\n    void visit(Circle& circle) override {\n        totalArea += 3.14159 * circle.radius * circle.radius;\n    }\n    void visit(Rectangle& rectangle) override {\n        totalArea += rectangle.width * rectangle.height;\n    }\n};\n\nint main() {\n    std::vector<std::unique_ptr<Shape>> shapes;\n    shapes.push_back(std::make_unique<Circle>(5.0));\n    shapes.push_back(std::make_unique<Rectangle>(4.0, 6.0));\n\n    AreaVisitor areaCalc;\n    for (auto& shape : shapes) {\n        shape->accept(areaCalc);\n    }\n    std::cout << "Total area: " << areaCalc.totalArea << std::endl;\n    return 0;\n}\n

Quand l'utiliser : lorsque vous devez effectuer différentes opérations sur des objets d'une hiérarchie complexe sans modifier leur code. Inconvénient — l'ajout d'un nouveau type nécessite de modifier tous les visiteurs.

2. Patron Strategy (Stratégie) — changement flexible d'algorithmes à la volée

Strategy encapsule une famille d'algorithmes interchangeables et permet de les remplacer lors de l'exécution. En C++, cela est souvent implémenté via std::function ou des classes virtuelles.

Exemple : système de tri de données

#include <iostream>\n#include <vector>\n#include <algorithm>\n#include <memory>\n#include <functional>\n\n// Contexte utilisant la stratégie\nclass Sorter {\nprivate:\n    std::function<void(std::vector<int>&)> strategy_;\npublic:\n    explicit Sorter(std::function<void(std::vector<int>&)> strategy)\n        : strategy_(std::move(strategy)) {}\n\n    void setStrategy(std::function<void(std::vector<int>&)> newStrategy) {\n        strategy_ = std::move(newStrategy);\n    }\n\n    void sort(std::vector<int>& data) {\n        if (strategy_) {\n            strategy_(data);\n        }\n    }\n};\n\n// Stratégies concrètes\nvoid bubbleSort(std::vector<int>& da