Patrón Strategy

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 95 de 104.

El patrón Strategy define una familia de algoritmos, encapsula cada uno de ellos y permite intercambiarlos. Esto te permite cambiar el comportamiento de un objeto en tiempo de ejecución sin modificar su código: el algoritmo varía independientemente de los clientes que lo utilizan.

El patrón consta de tres partes: una interfaz Strategy que declara el método del algoritmo, estrategias concretas que implementan diferentes variantes y un contexto que utiliza una estrategia:

#include <iostream>
#include <memory>

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

// Estrategias concretas
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";
    }
};

// Contexto
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 no sabe qué método de pago está usando; simplemente llama a pay() en cualquier estrategia que esté configurada. Puedes intercambiar estrategias en tiempo de ejecución con setPaymentMethod(), lo que hace que el sistema sea flexible y fácil de ampliar con nuevas opciones de pago.

Usa Strategy cuando tengas varios algoritmos para una tarea específica y quieras cambiar entre ellos dinámicamente, o cuando quieras evitar instrucciones condicionales para seleccionar el comportamiento.

Desafío

Fácil

Construyamos una Calculadora de envíos que use el patrón Strategy para calcular los costos de entrega según diferentes métodos de envío. Este es un escenario práctico en el que necesitas intercambiar algoritmos durante la ejecución: el mismo paquete podría enviarse por tierra, aire o exprés, cada uno con su propia lógica de precios.

Organizarás tu código en tres archivos:

ShippingStrategy.h: Define tu interfaz de estrategia y las estrategias concretas de envío.
Crea una clase abstracta ShippingStrategy con un método virtual puro calculateCost(double weight) que devuelva el costo de envío como un double, junto con un destructor virtual.

Después implementa tres estrategias concretas:
- GroundShipping: cuesta 1.5 por unidad de peso (weight * 1.5)
- AirShipping: cuesta 4.0 por unidad de peso (weight * 4.0)
- ExpressShipping: cuesta 6.5 por unidad de peso más una tarifa fija de 10.0 (weight * 6.5 + 10.0)
ShippingService.h: Crea la clase de contexto que usa una estrategia de envío.
Tu clase ShippingService debe contener un std::unique_ptr<ShippingStrategy> como miembro privado. Implementa:
- Un método setStrategy(std::unique_ptr<ShippingStrategy> strategy) para cambiar el método de envío
- Un método calculateShipping(double weight) que use la estrategia actual para calcular y devolver el costo
Si no se ha establecido ninguna estrategia cuando se llama a calculateShipping, devuelve 0.0.
main.cpp: Demuestra el cambio de estrategias durante la ejecución.
Lee dos entradas:
1. Peso del paquete (double)
2. Método de envío: ground, air o express
Crea un ShippingService y establece la estrategia adecuada según el método introducido. Calcula e imprime el costo de envío.

Después cambia a una estrategia diferente (usa air si la entrada no fue air; de lo contrario, usa ground) y vuelve a calcular el costo para el mismo peso. Esto demuestra el poder de intercambiar estrategias durante la ejecución.

Imprime cada costo en su propia línea con exactamente un decimal, precedido por el nombre del método:
```
[Method]: $[cost]
```

Por ejemplo, con las entradas 5.0 y ground:

Ground: $7.5
Air: $20.0

Con las entradas 3.0 y express:

Express: $29.5
Air: $12.0

Con las entradas 10.0 y air:

Air: $40.0
Ground: $15.0

Observa cómo ShippingService no necesita conocer los detalles de cada algoritmo de precios. Simplemente delega en la estrategia que esté establecida actualmente. Puedes añadir fácilmente nuevos métodos de envío (como entrega con drones o entrega el mismo día) sin modificar en absoluto la clase de servicio.

Pruébalo tú mismo

#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;
    
    // Establece la salida a 1 lugar decimal
    std::cout << std::fixed << std::setprecision(1);
    
    ShippingService service;
    
    // TODO: Basado en el método de entrada ("ground", "air", o "express"):
    // 1. Establece la estrategia apropiada en el servicio
    // 2. Calcula e imprime el costo en el formato: "[Method]: $[cost]"
    
    // TODO: Cambia a una estrategia diferente:
    // - Si la entrada fue "air", cambia a GroundShipping
    // - De lo contrario, cambia a AirShipping
    // Calcula e imprime el nuevo costo
    
    return 0;
}