Pattern Strategy

Fa parte della sezione Programmazione orientata agli oggetti del percorso C++ di Coddy. Lezione 95 di 104.

Il pattern Strategy definisce una famiglia di algoritmi, incapsula ciascuno di essi e li rende intercambiabili. Questo ti permette di cambiare il comportamento di un oggetto in fase di esecuzione senza modificarne il codice: l’algoritmo varia indipendentemente dai client che lo utilizzano.

Il pattern è composto da tre parti: un’interfaccia Strategy che dichiara il metodo dell’algoritmo, le Strategie concrete che implementano diverse varianti e un Contesto che utilizza una strategia:

#include <iostream>
#include <memory>

// Interfaccia della strategia
class PaymentStrategy {
public:
    virtual void pay(int amount) = 0;
    virtual ~PaymentStrategy() = default;
};

// Strategie concrete
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";
    }
};

// Contesto
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);
}

ShoppingCart non sa quale metodo di pagamento sta usando: chiama semplicemente pay() sulla strategia impostata. Puoi sostituire le strategie durante l'esecuzione con setPaymentMethod(), rendendo il sistema flessibile e facile da estendere con nuove opzioni di pagamento.

Usa Strategy quando hai più algoritmi per un'attività specifica e vuoi passare dinamicamente da uno all'altro, oppure quando vuoi evitare istruzioni condizionali per selezionare il comportamento.

Sfida

Facile

Creiamo una calcolatrice delle spese di spedizione che usa il pattern Strategy per calcolare i costi di consegna in base ai diversi metodi di spedizione. È uno scenario pratico in cui devi poter sostituire gli algoritmi durante l'esecuzione: lo stesso pacco potrebbe essere spedito via terra, via aerea o con spedizione express, ciascuna con la propria logica di tariffazione.

Organizzerai il codice in tre file:

ShippingStrategy.h: definisci l'interfaccia della strategia e le strategie concrete di spedizione.
Crea una classe astratta ShippingStrategy con un metodo virtuale puro calculateCost(double weight) che restituisce il costo di spedizione come double, insieme a un distruttore virtuale.

Poi implementa tre strategie concrete:
- GroundShipping: costa 1.5 per unità di peso (weight * 1.5)
- AirShipping: costa 4.0 per unità di peso (weight * 4.0)
- ExpressShipping: costa 6.5 per unità di peso, più una tariffa fissa di 10.0 (weight * 6.5 + 10.0)
ShippingService.h: crea la classe contesto che utilizza una strategia di spedizione.
La tua classe ShippingService dovrebbe contenere un std::unique_ptr<ShippingStrategy> come membro privato. Implementa:
- Un metodo setStrategy(std::unique_ptr<ShippingStrategy> strategy) per cambiare il metodo di spedizione
- Un metodo calculateShipping(double weight) che utilizza la strategia corrente per calcolare e restituire il costo
Se non è impostata alcuna strategia quando viene chiamato calculateShipping, restituisci 0.0.
main.cpp: mostra come cambiare strategia durante l'esecuzione.
Leggi due input:
1. Peso del pacco (double)
2. Metodo di spedizione: ground, air o express
Crea un ShippingService e imposta la strategia appropriata in base al metodo inserito. Calcola e stampa il costo di spedizione.

Poi passa a una strategia diversa (usa air se l'input non era air, altrimenti usa ground) e calcola di nuovo il costo per lo stesso peso. Questo dimostra i vantaggi di poter sostituire le strategie durante l'esecuzione.

Stampa ogni costo su una riga separata con esattamente una cifra decimale, preceduto dal nome del metodo:
```
[Method]: $[cost]
```

Per esempio, con gli input 5.0 e ground:

Ground: $7.5
Air: $20.0

Con gli input 3.0 e express:

Express: $29.5
Air: $12.0

Con gli input 10.0 e air:

Air: $40.0
Ground: $15.0

Nota come ShippingService non debba conoscere i dettagli di ciascun algoritmo di tariffazione. Si limita a delegare alla strategia impostata in quel momento. Puoi aggiungere facilmente nuovi metodi di spedizione (come la consegna con drone o in giornata) senza modificare affatto la classe del servizio.

Provalo tu

#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;
    
    // Imposta l'output a 1 cifra decimale
    std::cout << std::fixed << std::setprecision(1);
    
    ShippingService service;
    
    // TODO: In base al metodo inserito ("ground", "air" o "express"):
    // 1. Imposta la strategia appropriata nel servizio
    // 2. Calcola e stampa il costo nel formato: "[Method]: $[cost]"
    
    // TODO: Passa a una strategia diversa:
    // - Se il valore inserito era "air", passa a GroundShipping
    // - Altrimenti, passa a AirShipping
    // Calcola e stampa il nuovo costo
    
    return 0;
}