What are some examples of the Strategy design pattern in C++ and Java?

What are some examples of the Strategy design pattern in C++ and Java?

The Strategy design pattern allows you to define a family of algorithms, encapsulate each one, and make them interchangeable. In C++, you might use function pointers or functors, while in Java, you can use interfaces and classes. Would you like to see specific code examples?

Yes, please provide a C++ example.

Sure! Here's a simple C++ example:

#include <iostream>
#include <memory>

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

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

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

class Context {
private:
    std::unique_ptr<Strategy> strategy;
public:
    void setStrategy(std::unique_ptr<Strategy> newStrategy) {
        strategy = std::move(newStrategy);
    }
    void executeStrategy() {
        if (strategy) strategy->execute();
    }
};

int main() {
    Context context;
    context.setStrategy(std::make_unique<ConcreteStrategyA>());
    context.executeStrategy();
    context.setStrategy(std::make_unique<ConcreteStrategyB>());
    context.executeStrategy();
    return 0;
}

This code demonstrates how to switch between different strategies.

Great! Now can you show me a Java example?

Absolutely! Here's a Java example:

interface Strategy {
    void execute();
}

class ConcreteStrategyA implements Strategy {
    public void execute() { System.out.println("Executing Strategy A"); }
}

class ConcreteStrategyB implements Strategy {
    public void execute() { System.out.println("Executing Strategy B"); }
}

class Context {
    private Strategy strategy;
    public void setStrategy(Strategy strategy) { this.strategy = strategy; }
    public void executeStrategy() { if (strategy != null) strategy.execute(); }
}

public class Main {
    public static void main(String[] args) {
        Context context = new Context();
        context.setStrategy(new ConcreteStrategyA());
        context.executeStrategy();
        context.setStrategy(new ConcreteStrategyB());
        context.executeStrategy();
    }
}

This Java code illustrates the same concept of the Strategy pattern.