Patron Stratégie

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

Le patron de conception Stratégie définit une famille d'algorithmes, encapsule chacun d'eux et les rend interchangeables. Cela vous permet de modifier le comportement d'un objet au moment de l'exécution sans modifier son code - l'algorithme varie indépendamment des clients qui l'utilisent.

Le patron se compose de trois parties : une interface Strategy déclarant la méthode de l'algorithme, des stratégies concrètes implémentant différentes variations, et un contexte qui utilise une stratégie :

#include <iostream>
#include <memory>

// Interface de stratégie (Strategy interface)
class PaymentStrategy {
public:
    virtual void pay(int amount) = 0;
    virtual ~PaymentStrategy() = default;
};

// Stratégies concrètes (Concrete strategies)
class CreditCardPayment : public PaymentStrategy {
public:
    void pay(int amount) override {
        std::cout << "Paid " << amount << " via Credit Card\n";
    }
};

class PayPalPayment : public PaymentStrategy {
public:
    void pay(int amount) override {
        std::cout << "Paid " << amount << " via PayPal\n";
    }
};

// Contexte (Context)
class ShoppingCart {
    std::unique_ptr<PaymentStrategy> strategy;
public:
    void setPaymentMethod(std::unique_ptr<PaymentStrategy> s) {
        strategy = std::move(s);
    }
    
    void checkout(int total) {
        if (strategy) strategy->pay(total);
    }
};

int main() {
    ShoppingCart cart;
    
    cart.setPaymentMethod(std::make_unique<CreditCardPayment>());
    cart.checkout(100);
    
    cart.setPaymentMethod(std::make_unique<PayPalPayment>());
    cart.checkout(50);
}

Le ShoppingCart ne sait pas quel mode de paiement il utilise - il appelle simplement pay() sur n'importe quelle stratégie définie. Vous pouvez changer de stratégie au moment de l'exécution avec setPaymentMethod(), rendant le système flexible et facile à étendre avec de nouvelles options de paiement.

Utilisez le patron Strategy lorsque vous disposez de plusieurs algorithmes pour une tâche spécifique et que vous souhaitez basculer de l'un à l'autre de manière dynamique, ou lorsque vous voulez éviter les instructions conditionnelles pour sélectionner un comportement.

Défi

Facile

Construisons un Calculateur d'Expédition qui utilise le motif de conception Stratégie (Strategy pattern) pour calculer les frais de livraison en fonction de différentes méthodes d'expédition. Il s'agit d'un scénario pratique où vous devez échanger des algorithmes au moment de l'exécution — le même colis peut être expédié par voie terrestre, aérienne ou express, chacun ayant sa propre logique de tarification.

Vous organiserez votre code sur trois fichiers :

ShippingStrategy.h : Définissez votre interface de stratégie et les stratégies d'expédition concrètes.
Créez une classe abstraite ShippingStrategy avec une méthode virtuelle pure calculateCost(double weight) qui retourne le coût d'expédition sous forme de double, ainsi qu'un destructeur virtuel.

Ensuite, implémentez trois stratégies concrètes :
- GroundShipping — coûte 1.5 par unité de poids (weight * 1.5)
- AirShipping — coûte 4.0 par unité de poids (weight * 4.0)
- ExpressShipping — coûte 6.5 par unité de poids plus des frais fixes de 10.0 (weight * 6.5 + 10.0)
ShippingService.h : Créez la classe de contexte qui utilise une stratégie d'expédition.
Votre classe ShippingService doit contenir un std::unique_ptr<ShippingStrategy> en tant que membre privé. Implémentez :
- Une méthode setStrategy(std::unique_ptr<ShippingStrategy> strategy) pour changer la méthode d'expédition
- Une méthode calculateShipping(double weight) qui utilise la stratégie actuelle pour calculer et retourner le coût
Si aucune stratégie n'est définie lors de l'appel à calculateShipping, retournez 0.0.
main.cpp : Démontrez le changement de stratégies au moment de l'exécution.
Lisez deux entrées :
1. Le poids du colis (double)
2. La méthode d'expédition : ground, air, ou express
Créez un ShippingService et définissez la stratégie appropriée en fonction de la méthode saisie. Calculez et affichez le coût d'expédition.

Ensuite, passez à une stratégie différente (utilisez air si l'entrée n'était pas air, sinon utilisez ground) et calculez à nouveau le coût pour le même poids. Cela démontre la puissance de l'échange de stratégies au moment de l'exécution.

Affichez chaque coût sur sa propre ligne avec exactement une décimale, préfixé par le nom de la méthode :
```
[Method]: $[cost]
```

Par exemple, avec les entrées 5.0 et ground :

Ground: $7.5
Air: $20.0

Avec les entrées 3.0 et express :

Express: $29.5
Air: $12.0

Avec les entrées 10.0 et air :

Air: $40.0
Ground: $15.0

Remarquez comment le ShippingService n'a pas besoin de connaître les détails de chaque algorithme de tarification — il délègue simplement à la stratégie actuellement définie. Vous pouvez facilement ajouter de nouvelles méthodes d'expédition (comme la livraison par drone ou le jour même) sans modifier du tout la classe de service.

Aide-mémoire

Le patron de conception Stratégie (Strategy pattern) définit une famille d'algorithmes, encapsule chacun d'eux et les rend interchangeables. Cela permet de modifier le comportement d'un objet au moment de l'exécution sans modifier son code.

Le patron se compose de trois parties :

Interface Stratégie : Une classe abstraite déclarant la méthode de l'algorithme
Stratégies concrètes : Des classes implémentant différentes variantes de l'algorithme
Contexte : Une classe qui utilise une stratégie et peut basculer de l'une à l'autre

// Strategy interface
class PaymentStrategy {
public:
    virtual void pay(int amount) = 0;
    virtual ~PaymentStrategy() = default;
};

// Concrete strategies
class CreditCardPayment : public PaymentStrategy {
public:
    void pay(int amount) override {
        std::cout << "Paid " << amount << " via Credit Card\n";
    }
};

class PayPalPayment : public PaymentStrategy {
public:
    void pay(int amount) override {
        std::cout << "Paid " << amount << " via PayPal\n";
    }
};

// Context
class ShoppingCart {
    std::unique_ptr<PaymentStrategy> strategy;
public:
    void setPaymentMethod(std::unique_ptr<PaymentStrategy> s) {
        strategy = std::move(s);
    }
    
    void checkout(int total) {
        if (strategy) strategy->pay(total);
    }
};

Le contexte ne sait pas quelle stratégie concrète il utilise — il appelle simplement la méthode de l'interface. Les stratégies peuvent être échangées au moment de l'exécution à l'aide d'une méthode de modification (setter) :

ShoppingCart cart;

cart.setPaymentMethod(std::make_unique<CreditCardPayment>());
cart.checkout(100);

cart.setPaymentMethod(std::make_unique<PayPalPayment>());
cart.checkout(50);

Quand l'utiliser : Utilisez le patron Stratégie lorsque vous disposez de plusieurs algorithmes pour une tâche spécifique et que vous souhaitez basculer de l'un à l'autre de manière dynamique, ou lorsque vous voulez éviter les instructions conditionnelles pour sélectionner un comportement.

Essayez vous-même

#include <iostream>
#include <string>
#include <iomanip>
#include <memory>
#include "ShippingStrategy.h"
#include "ShippingService.h"

int main() {
    double weight;
    std::string method;
    
    std::cin >> weight;
    std::cin >> method;
    
    // Régler la sortie à 1 décimale
    std::cout << std::fixed << std::setprecision(1);
    
    ShippingService service;
    
    // TODO: Selon la méthode d'entrée ("ground", "air", ou "express") :
    // 1. Définir la stratégie appropriée sur le service
    // 2. Calculer et afficher le coût au format : "[Method]: $[cost]"
    
    // TODO: Passer à une stratégie différente :
    // - Si l'entrée était "air", passer à GroundShipping
    // - Sinon, passer à AirShipping
    // Calculer et afficher le nouveau coût
    
    return 0;
}