Strategy

Intent

Defines a family of algorithms, puts each in its own class, and makes them interchangeable.

Problem

Shipping cost logic for ground, air and express sits in one growing switch statement.

Solution

Extract each algorithm into a strategy with a common interface. The context holds one and delegates. In languages with first-class functions, a strategy can be a function.

Real-world analogy

Structure

Hover or tap a numbered role to highlight it in the diagram.

1. 1Context — Context keeps a reference to one strategy and talks to it only through the interface.
2. 2Strategy — Strategy declares the interface common to every algorithm variant.
3. 3ConcreteStrategies — Concrete Strategies implement the variations of the algorithm.
4. 4Context — Each time the context runs the algorithm, it calls execute() on its current strategy.
5. 5Client — Client creates a strategy and passes it to the context, and can swap it at runtime.

Try it

Code example

struct ShippingStrategy {
    virtual ~ShippingStrategy() = default;
    virtual double cost(double kg) const = 0;
};
struct Ground : ShippingStrategy { double cost(double kg) const override { return 5 + kg * 1.2; } };
struct Air    : ShippingStrategy { double cost(double kg) const override { return 15 + kg * 3.0; } };

class Order {
public:
    explicit Order(std::unique_ptr<ShippingStrategy> s) : strategy(std::move(s)) {}
    void setStrategy(std::unique_ptr<ShippingStrategy> s) { strategy = std::move(s); }
    double shipping(double kg) const { return strategy->cost(kg); }
private:
    std::unique_ptr<ShippingStrategy> strategy;
};

// Order order(std::make_unique<Air>());
// order.shipping(2.0);   // 21

Applicability

How to implement

1. Identify the algorithm that varies
2. Declare the strategy interface (or function type)
3. Extract each algorithm into a strategy
4. Give the context a strategy field and a setter
5. Clients choose and inject the strategy

Pros and cons

Relations with other patterns

Check yourself