Patron Décorateur

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

Le pattern Décorateur vous permet d'ajouter de nouveaux comportements aux objets de manière dynamique en les enveloppant dans des objets spéciaux appelés décorateurs. Contrairement à l'héritage, qui ajoute du comportement au moment de la compilation, les décorateurs vous permettent d'étendre les fonctionnalités au moment de l'exécution sans modifier la classe originale.

Le patron fonctionne en faisant en sorte que l'objet original et les décorateurs implémentent la même interface. Chaque décorateur détient une référence vers un composant et ajoute son propre comportement avant ou après avoir délégué à l'objet enveloppé :

#include <iostream>
#include <memory>

// Interface du composant
class Coffee {
public:
    virtual std::string getDescription() const = 0;
    virtual double getCost() const = 0;
    virtual ~Coffee() = default;
};

// Composant concret
class SimpleCoffee : public Coffee {
public:
    std::string getDescription() const override { return "Coffee"; }
    double getCost() const override { return 2.0; }
};

// Décorateur de base
class CoffeeDecorator : public Coffee {
protected:
    std::unique_ptr<Coffee> coffee;
public:
    CoffeeDecorator(std::unique_ptr<Coffee> c) : coffee(std::move(c)) {}
};

// Décorateurs concrets
class MilkDecorator : public CoffeeDecorator {
public:
    MilkDecorator(std::unique_ptr<Coffee> c) : CoffeeDecorator(std::move(c)) {}
    std::string getDescription() const override {
        return coffee->getDescription() + ", Milk";
    }
    double getCost() const override { return coffee->getCost() + 0.5; }
};

class SugarDecorator : public CoffeeDecorator {
public:
    SugarDecorator(std::unique_ptr<Coffee> c) : CoffeeDecorator(std::move(c)) {}
    std::string getDescription() const override {
        return coffee->getDescription() + ", Sugar";
    }
    double getCost() const override { return coffee->getCost() + 0.2; }
};

Les décorateurs peuvent être empilés - chacun enveloppe le précédent, ajoutant des fonctionnalités couche par couche :

int main() {
    std::unique_ptr<Coffee> order = std::make_unique<SimpleCoffee>();
    order = std::make_unique<MilkDecorator>(std::move(order));
    order = std::make_unique<SugarDecorator>(std::move(order));
    
    std::cout << order->getDescription() << ": $" << order->getCost();
    // Sortie : Coffee, Milk, Sugar: $2.7
}

Utilisez le motif Décorateur lorsque vous avez besoin d'ajouter des responsabilités à des objets de manière dynamique sans affecter les autres objets, ou lorsque l'extension des fonctionnalités par sous-classement entraînerait une explosion de classes.

Défi

Facile

Construisons un Système de Commande de Pizza en utilisant le patron de conception Decorator (Décorateur). Vous allez créer un système flexible où les clients peuvent commencer par une pizza de base et ajouter diverses garnitures — chaque garniture enveloppe la commande précédente et ajoute son propre coût et sa propre description. C'est un cas d'utilisation parfait pour les décorateurs : les garnitures peuvent être empilées dans n'importe quelle combinaison sans créer une explosion de sous-classes.

Vous organiserez votre code sur trois fichiers :

Pizza.h : Définissez l'interface du composant et la classe de pizza de base.
Créez une classe abstraite Pizza avec des méthodes virtuelles pures getDescription() (retourne une chaîne de caractères) et getCost() (retourne un double), ainsi qu'un destructeur virtuel.

Ensuite, créez une classe concrète PlainPizza qui représente la pizza de base. Elle doit retourner "Pizza" comme description et avoir un coût de base de 8.0.
ToppingDecorator.h : Construisez la classe de base du décorateur et les décorateurs de garnitures concrets.
Créez une classe ToppingDecorator qui hérite de Pizza et contient un std::unique_ptr<Pizza> vers le composant enveloppé. Cela sert de base à tous les décorateurs de garnitures.

Implémentez trois décorateurs de garnitures concrets :
- CheeseTopping — ajoute ", Cheese" à la description et 1.5 au coût
- PepperoniTopping — ajoute ", Pepperoni" à la description et 2.0 au coût
- MushroomTopping — ajoute ", Mushrooms" à la description et 1.0 au coût
Chaque décorateur doit déléguer à la pizza enveloppée, puis ajouter sa propre contribution.
main.cpp : Créez une commande de pizza personnalisée basée sur l'entrée de l'utilisateur.
Lisez trois entrées (chacune sera yes ou no) :
1. Ajouter du fromage ?
2. Ajouter du pepperoni ?
3. Ajouter des champignons ?
Commencez par une PlainPizza, puis enveloppez-la avec les décorateurs de garnitures appropriés en fonction des entrées (dans l'ordre : fromage, pepperoni, champignons). Enfin, affichez les détails de la commande dans ce format :
```
Order: [description]
Total: $[cost]
```

Par exemple, avec les entrées yes, yes, no :

Order: Pizza, Cheese, Pepperoni
Total: $11.5

Avec les entrées yes, no, yes :

Order: Pizza, Cheese, Mushrooms
Total: $10.5

Avec les entrées no, no, no :

Order: Pizza
Total: $8

Avec les entrées yes, yes, yes :

Order: Pizza, Cheese, Pepperoni, Mushrooms
Total: $12.5

Remarquez comment chaque décorateur enveloppe le précédent, construisant à la fois la description et le coût couche par couche. Vous pouvez facilement ajouter de nouvelles garnitures en créant de nouvelles classes de décorateurs sans modifier le code existant de la pizza ou des garnitures — c'est toute la beauté du patron Decorator.

Aide-mémoire

Le patron Décorateur (Decorator pattern) vous permet d'ajouter dynamiquement de nouveaux comportements à des objets en les enveloppant dans des objets spéciaux appelés décorateurs. Contrairement à l'héritage, qui ajoute du comportement au moment de la compilation, les décorateurs vous permettent d'étendre les fonctionnalités au moment de l'exécution sans modifier la classe d'origine.

Le patron fonctionne en faisant en sorte que l'objet d'origine et les décorateurs implémentent la même interface. Chaque décorateur détient une référence à un composant et ajoute son propre comportement avant ou après avoir délégué l'appel à l'objet enveloppé.

Structure

Interface du composant : Définit l'interface commune pour les composants concrets et les décorateurs.

class Coffee {
public:
    virtual std::string getDescription() const = 0;
    virtual double getCost() const = 0;
    virtual ~Coffee() = default;
};

Composant concret : L'objet de base qui peut être décoré.

class SimpleCoffee : public Coffee {
public:
    std::string getDescription() const override { return "Coffee"; }
    double getCost() const override { return 2.0; }
};

Décorateur de base : Détient une référence à un composant et implémente la même interface.

class CoffeeDecorator : public Coffee {
protected:
    std::unique_ptr<Coffee> coffee;
public:
    CoffeeDecorator(std::unique_ptr<Coffee> c) : coffee(std::move(c)) {}
};

Décorateurs concrets : Ajoutent des comportements spécifiques en déléguant à l'objet enveloppé et en ajoutant leur propre fonctionnalité.

class MilkDecorator : public CoffeeDecorator {
public:
    MilkDecorator(std::unique_ptr<Coffee> c) : CoffeeDecorator(std::move(c)) {}
    std::string getDescription() const override {
        return coffee->getDescription() + ", Milk";
    }
    double getCost() const override { return coffee->getCost() + 0.5; }
};

Empilement de décorateurs

Les décorateurs peuvent être empilés - chacun enveloppe le précédent, construisant la fonctionnalité couche par couche :

std::unique_ptr<Coffee> order = std::make_unique<SimpleCoffee>();
order = std::make_unique<MilkDecorator>(std::move(order));
order = std::make_unique<SugarDecorator>(std::move(order));

std::cout << order->getDescription() << ": $" << order->getCost();
// Output: Coffee, Milk, Sugar: $2.7

Quand l'utiliser

Utilisez le Décorateur lorsque vous devez ajouter des responsabilités à des objets de manière dynamique sans affecter les autres objets, ou lorsque l'extension des fonctionnalités par sous-classement entraînerait une explosion du nombre de classes.

Essayez vous-même

#include <iostream>
#include <string>
#include <memory>
#include "Pizza.h"
#include "ToppingDecorator.h"

using namespace std;

int main() {
    // Lire trois entrées (yes ou no)
    string addCheese, addPepperoni, addMushrooms;
    cin >> addCheese;
    cin >> addPepperoni;
    cin >> addMushrooms;
    
    // TODO: Commencer avec une PlainPizza en utilisant std::unique_ptr
    
    // TODO: Si addCheese est "yes", envelopper la pizza avec CheeseTopping
    
    // TODO: Si addPepperoni est "yes", envelopper la pizza avec PepperoniTopping
    
    // TODO: Si addMushrooms est "yes", envelopper la pizza avec MushroomTopping
    
    // TODO: Afficher la commande au format :
    // Order: [description]
    // Total: $[cost]
    
    return 0;
}