Example of Strategy Pattern in C++

This article introduces the Strategy Pattern in C++, explaining how it works and providing a specific illustrative example to help you better understand this design pattern in object-oriented programming.

The Strategy Pattern is a design pattern that allows changing the behavior of an object at runtime. This pattern is often used to separate algorithms from the class that uses them, making it easier to extend and maintain code. In this article, we will learn how to implement the Strategy Pattern in C++ through a simple example.

C++ code

#include <iostream>
#include <memory>

// Base Strategy
class Strategy {
public:
    virtual void execute() = 0; // Pure virtual function
};

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

// Concrete Strategy B
class ConcreteStrategyB : public Strategy {
public:
    void execute() override {
        std::cout << "Executing Strategy B" << std::endl;
    }
};

// Context using the strategy
class Context {
private:
    std::unique_ptr<Strategy> strategy; // Smart pointer to Strategy

public:
    void setStrategy(std::unique_ptr<Strategy> newStrategy) {
        strategy = std::move(newStrategy);
    }

    void executeStrategy() {
        if (strategy) {
            strategy->execute();
        } else {
            std::cout << "Strategy not set!" << std::endl;
        }
    }
};

int main() {
    Context context;

    context.setStrategy(std::make_unique<ConcreteStrategyA>());
    context.executeStrategy(); // Output: Executing Strategy A

    context.setStrategy(std::make_unique<ConcreteStrategyB>());
    context.executeStrategy(); // Output: Executing Strategy B

    return 0;
}

Detailed explanation

1. Strategy: The base class with a pure virtual method execute(), defining the interface for specific strategies.
2. ConcreteStrategyA and ConcreteStrategyB: Concrete classes inheriting from Strategy, defining different behaviors for the execute() method.
3. Context: This class contains a smart pointer strategy, allowing the setup and execution of the strategy.
4. setStrategy(): A method used to set a new strategy for the context.
5. executeStrategy(): A method that calls the behavior of the strategy that has been set.
6. In main(), we create a Context, set different strategies, and call the executeStrategy() method to execute.

System Requirements:

• C++11 or later

How to install the libraries needed to run the C++ code above:

The above code uses basic C++ features and does not require any external libraries to be installed.

Tips:

• The Strategy Pattern is very useful when you need to change an algorithm or behavior of an object without changing its source code.
• Consider using smart pointers (std::unique_ptr) to manage resources safely.