策略模式是一种行为型设计模式,它定义了一系列的算法,并将每个算法封装起来,使它们可以相互替换。
下面是一个使用 C++ 实现策略模式的示例代码:
#include <iostream>
#include <vector>
// 抽象策略类:定义了所有具体策略类的接口
class Strategy {
public:
virtual ~Strategy() {
}
virtual void ExecuteStrategy() = 0;
};
// 具体策略类:实现了抽象策略类的接口
class ConcreteStrategyA : public Strategy {
public:
virtual ~ConcreteStrategyA() {
}
virtual void ExecuteStrategy() override {
std::cout << "Concrete Strategy A" << std::endl;
}
};
class ConcreteStrategyB : public Strategy {
public:
virtual ~ConcreteStrategyB() {
}
virtual void ExecuteStrategy() override {
std::cout << "Concrete Strategy B" << std::endl;
}
};
// 上下文类:维护一个具体策略类的实例,并定义了一个接口供外部调用
class Context {
public:
Context(Strategy* strategy) : strategy_(strategy) {
}
~Context() {
delete strategy_;
}
void Execute() {
strategy_->ExecuteStrategy();
}
void ChangeStrategy(Strategy* strategy) {
delete strategy_;
strategy_ = strategy;
}
private:
Strategy* strategy_;
};
int main() {
// 创建具体策略对象
ConcreteStrategyA* strategy_a = new ConcreteStrategyA();
ConcreteStrategyB* strategy_b = new ConcreteStrategyB();
// 创建上下文对象,并设置初始策略为 ConcreteStrategyA
Context context(strategy_a);
// 调用上下文对象的接口,输出 "Concrete Strategy A"
context.Execute();
// 改变上下文对象的策略为 ConcreteStrategyB
context.ChangeStrategy(strategy_b);
// 再次调用上下文对象的接口,输出 "Concrete Strategy B"
context.Execute();
return 0;
}
在上面的代码中,我们首先定义了一个抽象策略类 Strategy,它定义了所有具体策略类的接口。接着,我们创建了两个具体策略类 ConcreteStrategyA 和 ConcreteStrategyB,它们实现了抽象策略类的接口。最后,我们定义了一个上下文类 Context,它维护了一个具体策略类的实例,并定义了一个接口供外部调用。
在 main() 函数中,我们创建了两个具体策略对象 strategy_a 和 strategy_b,并将 strategy_a 作为初始策略,然后创建了一个上下文对象 context,并调用它的接口 Execute() 输出 “Concrete Strategy A”。接着,我们将上下文对象的策略改变为 strategy_b,再次调用 Execute() 接口,输出 “Concrete Strategy B”。
策略模式的优点在于它将算法的实现与使用分离开来,并使得每个算法都可以独立地变化。同时,策略模式也使得我们可以简化条件语句的复杂度,使得代码更加清晰易懂。但是,策略模式可能会导致类的数量增加,从而增加了代码的复杂度。