What is the Strategy Pattern in C++?

Can you explain the Strategy Pattern in C++?

Sure! The Strategy Pattern is a behavioral design pattern that enables selecting an algorithm's behavior at runtime.

How do I implement the Strategy Pattern in C++?

You can implement it by defining a strategy interface, creating concrete strategy classes, and a context class to use them.

Can you give me a code example?

Absolutely! Here's a simple example:

#include <iostream>

// Strategy interface
class Strategy {
public:
    virtual void execute() = 0;
};

// Concrete strategies
class ConcreteStrategyA : public Strategy {
public:
    void execute() override { std::cout << "Strategy A executed." << std::endl; }
};

class ConcreteStrategyB : public Strategy {
public:
    void execute() override { std::cout << "Strategy B executed." << std::endl; }
};

// Context
class Context {
private:
    Strategy* strategy;
public:
    void setStrategy(Strategy* s) { strategy = s; }
    void executeStrategy() { strategy->execute(); }
};

int main() {
    Context context;
    ConcreteStrategyA strategyA;
    ConcreteStrategyB strategyB;

    context.setStrategy(&strategyA);
    context.executeStrategy(); // Outputs: Strategy A executed.

    context.setStrategy(&strategyB);
    context.executeStrategy(); // Outputs: Strategy B executed.
}

This code demonstrates how to switch strategies at runtime.

What are the benefits of using the Strategy Pattern?

The benefits include improved code flexibility, easier maintenance, and the ability to add new strategies without modifying existing code.