中文策略编程是一种行为设计模式，它允许你在运行时选择算法的行为。策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互换。策略模式还使算法独立于使用它的客户端。
定义策略接口
首先，我们定义一个策略接口，通常是一个抽象基类，其中包含一个指向策略函数的指针。
```cpp
// Strategy.h
pragma once
// 策略接口
class Strategy {
public:
virtual ~Strategy（） = default；
virtual int execute（int x, int y） = 0；
}；
```
实现具体策略
然后，我们实现具体的策略类，这些类继承自策略接口，并实现`execute`方法。
```cpp
// AddStrategy.h
pragma once
include "Strategy.h"
class AddStrategy : public Strategy {
public:
int execute（int x, int y） override {
return x + y；
}
}；
// SubtractStrategy.h
pragma once
include "Strategy.h"
class SubtractStrategy : public Strategy {
public:
int execute（int x, int y） override {
return x - y；
}
}；
// MultiplyStrategy.h
pragma once
include "Strategy.h"
class MultiplyStrategy : public Strategy {
public:
int execute（int x, int y） override {
return x * y；
}
}；
// DivideStrategy.h
pragma once
include "Strategy.h"
class DivideStrategy : public Strategy {
public:
int execute（int x, int y） override {
if （y == 0） {
throw std::invalid_argument（"Division by zero"）；
}
return x / y；
}
}；
```
创建上下文类
上下文类使用策略接口，并在运行时设置具体的策略。
```cpp
// Context.h
pragma once
include "Strategy.h"
class Context {
private:
Strategy* strategy；
public:
Context（Strategy* strategy） : strategy（strategy） {}
void setStrategy（Strategy* strategy） {
this->strategy = strategy；
}
int executeStrategy（int x, int y） {
return strategy->execute（x, y）；
}
}；
```
使用策略
最后，在客户端代码中，我们可以创建上下文对象，并设置不同的策略来执行计算。
```cpp
// main.cpp
include include "AddStrategy.h" include "SubtractStrategy.h" include "MultiplyStrategy.h" include "DivideStrategy.h" include "Context.h" int main（） { Context context（new AddStrategy（））； std::cout << "Result with Add Strategy: " << context.executeStrategy（6, 4） << std::endl； context.setStrategy（new SubtractStrategy（））； std::cout << "Result with Subtract Strategy: " << context.executeStrategy（6, 4） << std::endl； context.setStrategy（new MultiplyStrategy（））； std::cout << "Result with Multiply Strategy: " << context.executeStrategy（6, 4） << std::endl； context.setStrategy（new DivideStrategy（））； std::cout << "Result with Divide Strategy: " << context.executeStrategy（6, 4） << std::endl； // 释放内存 delete context.executeStrategy（6, 4）； delete context.executeStrategy（6, 4）； delete context.executeStrategy（6, 4）； delete context.executeStrategy（6, 4）； return 0； } ``` 注意：在实际项目中，为了避免内存泄漏，建议使用智能指针（如`std::unique_ptr`或`std::shared_ptr`）来管理策略对象的生命周期。 这个示例展示了如何使用策略模式来动态地改变算法的行为。你可以根据需要添加更多的策略类，并在客户端代码中灵活地选择它们。