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 los hace intercambiables. Esto 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 variaciones, y un Contexto que utiliza una estrategia:

#include <iostream>
#include <memory>

// Interfaz de Estrategia
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);
}

El ShoppingCart no sabe qué método de pago está utilizando; 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 extender con nuevas opciones de pago.

Utiliza Strategy cuando tengas múltiples algoritmos para una tarea específica y quieras cambiar entre ellos dinámicamente, o cuando quieras evitar sentencias condicionales para seleccionar el comportamiento.

Desafío

Fácil

Vamos a construir una Calculadora de Envío que utiliza el patrón Strategy para calcular los costos de entrega basados en diferentes métodos de envío. Este es un escenario práctico donde necesitas intercambiar algoritmos en tiempo de ejecución: el mismo paquete puede enviarse por tierra, aire o expreso, 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 de envío concretas.
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.

Luego 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 utiliza 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 utilice la estrategia actual para calcular y devolver el costo
Si no hay ninguna estrategia establecida cuando se llama a calculateShipping, devuelve 0.0.
main.cpp: Demuestra el intercambio de estrategias en tiempo de 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 basada en el método de entrada. Calcula e imprime el costo de envío.

Luego cambia a una estrategia diferente (usa air si la entrada no fue air, de lo contrario usa ground) y calcula el costo nuevamente para el mismo peso. Esto demuestra el poder de intercambiar estrategias en tiempo de 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 el ShippingService no necesita conocer los detalles de cada algoritmo de precios; simplemente delega en cualquier estrategia que esté establecida actualmente. Puedes añadir fácilmente nuevos métodos de envío (como entrega por dron o en el mismo día) sin modificar la clase de servicio en absoluto.

Hoja de referencia

El patrón consta de tres partes:

Interfaz Strategy: Una clase abstracta que declara el método del algoritmo
Estrategias Concretas: Clases que implementan diferentes variaciones del algoritmo
Contexto: Una clase que utiliza una estrategia y puede cambiar entre ellas

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

El contexto no sabe qué estrategia concreta está utilizando; simplemente llama al método de la interfaz. Las estrategias se pueden intercambiar en tiempo de ejecución mediante un método setter:

ShoppingCart cart;

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

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

Cuándo usarlo: Utilice Strategy cuando tenga múltiples algoritmos para una tarea específica y desee cambiar entre ellos dinámicamente, o cuando desee evitar sentencias condicionales para seleccionar el comportamiento.

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;
    
    // Configura la salida a 1 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;
}