Strategy Pattern

The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable at runtime. In modern C++, you can implement this pattern using traditional polymorphism or functional std::function wrappers.

Dynamic vs. Static Strategies

You can implement strategies in two ways:

• Dynamic Strategy: Uses virtual base classes and pointers. This is flexible and allows you to swap strategies at runtime, but introduces virtual table dispatch overhead.
• Static Strategy: Uses templates (e.g. template <typename Strategy> class Context). This allows the compiler to inline code and optimize performance, but binds the strategy at compile time.

Code Walkthrough

Implementing strategies using polymorphism and functional std::function wrappers.

#include <iostream>
#include <vector>
#include <functional>
// 1. Dynamic Strategy using std::function
class TextValidator {
private:
    std::function<bool(const std::string&)> m_strategy;
public:
    TextValidator(std::function<bool(const std::string&)> strategy) 
        : m_strategy(strategy) {}
void setStrategy(std::function<bool(const std::string&)> strategy) {
        m_strategy = strategy;
    }
bool validate(const std::string& text) {
        return m_strategy ? m_strategy(text) : false;
    }
};
int main() {
    // Strategies can be passed as simple lambdas
    auto lowerCaseCheck = [](const std::string& s) {
        for (char c : s) { if (isupper(c)) return false; }
        return true;
    };
TextValidator validator(lowerCaseCheck);
    std::cout << "Is 'hello' valid? " << std::boolalpha << validator.validate("hello") << "\n";
// Swap strategy at runtime
    validator.setStrategy([](const std::string& s) {
        return s.length() > 5;
    });
    std::cout << "Is 'hello' valid? " << validator.validate("hello") << "\n";
return 0;
}

Interview-Relevant Information