引言

在软件开发中，我们常常会遇到需要在运行时动态选择和切换算法或行为的场景。例如，电商系统中的多种支付方式、游戏中的不同难度设置，或是计算器中的各种运算符。传统的方法可能会使用复杂的条件判断语句（如if-else或switch-case）来实现这些功能，但随着需求的增加，代码会变得难以维护和扩展。

为了解决这一问题，策略模式（Strategy Pattern）应运而生。作为一种行为设计模式，策略模式允许我们将一系列算法或行为封装到独立的类中，并在运行时动态选择和切换这些策略。这种方式不仅提高了代码的可维护性和扩展性，还使算法的实现与调用分离，便于管理和复用。

本文将详细介绍C++中的策略模式，包括其基本概念、结构组成、实际应用示例以及优缺点分析。

策略模式的基本概念

策略模式的核心思想是将算法的实现与调用分离。通过定义一个统一的接口，将所有具体策略类的行为进行封装。这样，客户端代码无需关心具体算法的实现细节，只需选择并使用相应的策略即可。

具体来说，策略模式包含以下几个关键部分：

策略接口（Strategy Interface） ：定义所有具体策略类必须实现的接口。
具体策略类（Concrete Strategies） ：实现策略接口，提供具体的算法或行为。
上下文类（Context） ：持有一个策略接口的引用，并负责调用策略的算法。

通过这种方式，策略模式使得算法的实现与使用解耦，提高了系统的灵活性和可扩展性。

策略模式的结构组成

1. 策略接口

策略接口是所有具体策略类必须实现的接口。它定义了策略类必须实现的方法。

// 策略接口
class Strategy {
public:virtual ~Strategy() = default;virtual int calculate(int a, int b) = 0;
};

2. 具体策略类

具体策略类实现了策略接口，提供了具体的算法或行为。每个具体策略类对应一种特定的算法实现。

// 具体策略类：加法
class AddStrategy : public Strategy {
public:int calculate(int a, int b) override {return a + b;}
};// 具体策略类：减法
class SubtractStrategy : public Strategy {
public:int calculate(int a, int b) override {return a - b;}
};// 具体策略类：乘法
class MultiplyStrategy : public Strategy {
public:int calculate(int a, int b) override {return a * b;}
};

3. 上下文类

上下文类持有一个策略接口的引用，并负责调用策略的算法。客户端通过上下文类来使用不同的策略。

// 上下文类
class Context {
private:std::unique_ptr<Strategy> strategy;public:explicit Context(std::unique_ptr<Strategy> s) : strategy(std::move(s)) {}void set_strategy(std::unique_ptr<Strategy> s) {strategy = std::move(s);}int execute_strategy(int a, int b) {return strategy->calculate(a, b);}
};

策略模式的实际应用示例

为了更好地理解策略模式的应用，我们可以通过一个实际的例子来展示其使用场景。

示例：计算器支持多种运算

假设我们需要创建一个计算器，支持加、减、乘、除四种运算。每种运算可以作为一个独立的策略。

1. 定义策略接口

// 策略接口
class OperationStrategy {
public:virtual ~OperationStrategy() = default;virtual int operate(int a, int b) = 0;
};

2. 实现具体策略类

// 加法策略
class AddOperation : public OperationStrategy {
public:int operate(int a, int b) override {return a + b;}
};// 减法策略
class SubtractOperation : public OperationStrategy {
public:int operate(int a, int b) override {return a - b;}
};// 乘法策略
class MultiplyOperation : public OperationStrategy {
public:int operate(int a, int b) override {return a * b;}
};// 除法策略
class DivideOperation : public OperationStrategy {
public:int operate(int a, int b) override {if (b == 0) {throw std::invalid_argument("除数不能为零");}return a / b;}
};

3. 创建上下文类

// 上下文类
class Calculator {
private:std::unique_ptr<OperationStrategy> strategy;public:Calculator(std::unique_ptr<OperationStrategy> s) : strategy(std::move(s)) {}void set_strategy(std::unique_ptr<OperationStrategy> s) {strategy = std::move(s);}int calculate(int a, int b) {return strategy->operate(a, b);}
};

4. 客户端代码

int main() {// 创建不同策略std::unique_ptr<OperationStrategy> add = std::make_unique<AddOperation>();std::unique_ptr<OperationStrategy> subtract = std::make_unique<SubtractOperation>();std::unique_ptr<OperationStrategy> multiply = std::make_unique<MultiplyOperation>();std::unique_ptr<OperationStrategy> divide = std::make_unique<DivideOperation>();// 创建计算器上下文Calculator calculator(std::move(add));// 使用加法策略std::cout << "5 + 3 = " << calculator.calculate(5, 3) << std::endl;// 切换到减法策略calculator.set_strategy(std::move(subtract));std::cout << "5 - 3 = " << calculator.calculate(5, 3) << std::endl;// 切换到乘法策略calculator.set_strategy(std::move(multiply));std::cout << "5 * 3 = " << calculator.calculate(5, 3) << std::endl;// 切换到除法策略calculator.set_strategy(std::move(divide));std::cout << "6 / 3 = " << calculator.calculate(6, 3) << std::endl;return 0;
}

示例说明

在上述示例中，我们创建了一个支持多种运算的计算器。通过策略模式，我们可以动态地切换不同的运算策略，而无需修改上下文类的代码。具体来说：

策略接口 OperationStrategy 定义了所有运算策略必须实现的 operate 方法。
具体策略类 AddOperation、SubtractOperation、MultiplyOperation 和 DivideOperation 分别实现了加、减、乘、除四种运算。
上下文类 Calculator 持有当前使用的策略，并通过 calculate 方法调用策略的 operate 方法。
客户端代码 可以根据需要动态地切换不同的策略，实现灵活的运算功能。