烂人不配爱1. 策略模式的核心价值与应用场景
在C++开发中，策略模式（Strategy Pattern）是我最常使用的设计模式之一。它完美解决了当某个任务存在多种算法或实现方式时，如何优雅地组织和切换这些算法的问题。想象一下你正在开发一个支付系统，需要支持信用卡、支付宝、微信支付等多种支付方式——这正是策略模式的典型用武之地。
策略模式的核心思想是将算法族（一组相关的算法）封装成独立的类，使它们可以相互替换。这种模式让算法的变化独立于使用算法的客户端，符合开闭原则（对扩展开放，对修改关闭）。在实际项目中，我经常遇到以下场景会考虑使用策略模式：
- 支付系统不同支付方式的实现
- 数据压缩/加密算法的动态切换
- 排序算法的运行时选择（如快速排序、归并排序等）
- 游戏AI中不同行为策略的实现
- 报表生成的不同格式输出（PDF、Excel、CSV）
提示：策略模式特别适合那些在运行时需要动态切换算法或行为的场景。如果你的系统中有大量if-else或switch-case语句来处理不同的算法变体，很可能就是引入策略模式的好时机。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. C++策略模式的经典实现
让我们通过一个完整的示例来理解策略模式在C++中的实现方式。假设我们要开发一个文本处理工具，需要支持不同的文本转换策略（如全部大写、全部小写、首字母大写等）。
2.1 定义策略接口
首先，我们定义一个纯虚基类作为策略接口：
cpp复制class TextTransformStrategy {
public:
virtual ~TextTransformStrategy() = default;
virtual std::string transform(const std::string& input) const = 0;
};
这个接口非常简单，只包含一个纯虚函数transform()，所有具体策略都必须实现这个方法。使用虚析构函数是为了确保通过基类指针删除派生类对象时能正确调用派生类的析构函数。
2.2 实现具体策略类
接下来，我们实现几个具体的策略类：
cpp复制// 转换为大写策略
class UpperCaseStrategy : public TextTransformStrategy {
public:
std::string transform(const std::string& input) const override {
std::string result = input;
std::transform(result.begin(), result.end(), result.begin(),
[](unsigned char c){ return std::toupper(c); });
return result;
}
};
// 转换为小写策略
class LowerCaseStrategy : public TextTransformStrategy {
public:
std::string transform(const std::string& input) const override {
std::string result = input;
std::transform(result.begin(), result.end(), result.begin(),
[](unsigned char c){ return std::tolower(c); });
return result;
}
};
// 首字母大写策略
class CapitalizeStrategy : public TextTransformStrategy {
public:
std::string transform(const std::string& input) const override {
if (input.empty()) return input;
std::string result = input;
result[0] = std::toupper(result[0]);
for (size_t i = 1; i < result.size(); ++i) {
result[i] = std::tolower(result[i]);
}
return result;
}
};
每个具体策略类都实现了transform()方法，提供了不同的文本转换逻辑。注意这些策略类之间是完全独立的，可以单独修改或扩展而不影响其他策略。
2.3 实现上下文类
上下文类（Context）是策略模式的核心，它持有一个策略对象的引用，并将工作委托给策略对象：
cpp复制class TextProcessor {
private:
std::unique_ptr<TextTransformStrategy> strategy_;
public:
// 设置策略
void setStrategy(std::unique_ptr<TextTransformStrategy>&& strategy) {
strategy_ = std::move(strategy);
}
// 执行转换
std::string processText(const std::string& input) {
if (strategy_) {
return strategy_->transform(input);
}
return input; // 默认行为（无策略时）
}
};
上下文类TextProcessor不关心具体使用哪种策略，它只通过策略接口与策略对象交互。这使得我们可以随时更换策略而不需要修改上下文类的代码。
2.4 客户端使用示例
最后是客户端代码，展示如何使用这个策略模式实现：
cpp复制int main() {
TextProcessor processor;
std::string testText = "Hello, Strategy Pattern!";
// 使用大写策略
processor.setStrategy(std::make_unique<UpperCaseStrategy>());
std::cout << processor.processText(testText) << std::endl;
// 切换为小写策略
processor.setStrategy(std::make_unique<LowerCaseStrategy>());
std::cout << processor.processText(testText) << std::endl;
// 切换为首字母大写策略
processor.setStrategy(std::make_unique<CapitalizeStrategy>());
std::cout << processor.processText(testText) << std::endl;
return 0;
}
输出结果：
code复制HELLO, STRATEGY PATTERN!
hello, strategy pattern!
Hello, strategy pattern!
3. 策略模式的高级应用技巧
在实际项目中，策略模式的应用远不止简单的算法切换。下面分享几个我在实际开发中使用策略模式的高级技巧。
3.1 策略工厂模式
当策略对象创建逻辑复杂时，可以结合工厂模式来管理策略的创建：
cpp复制class StrategyFactory {
public:
enum class StrategyType { UpperCase, LowerCase, Capitalize };
static std::unique_ptr<TextTransformStrategy> create(StrategyType type) {
switch (type) {
case StrategyType::UpperCase:
return std::make_unique<UpperCaseStrategy>();
case StrategyType::LowerCase:
return std::make_unique<LowerCaseStrategy>();
case StrategyType::Capitalize:
return std::make_unique<CapitalizeStrategy>();
default:
throw std::invalid_argument("Unknown strategy type");
}
}
};
// 使用示例
processor.setStrategy(StrategyFactory::create(StrategyFactory::StrategyType::UpperCase));
这种方法将策略的创建逻辑集中管理，客户端代码只需要知道策略类型枚举，而不需要了解具体策略类的细节。
3.2 使用函数对象替代类层次
在C++中，我们还可以使用函数对象（functor）或lambda表达式来实现策略模式，避免创建复杂的类层次：
cpp复制class TextProcessor {
public:
using Strategy = std::function<std::string(const std::string&)>;
void setStrategy(Strategy strategy) {
strategy_ = std::move(strategy);
}
std::string processText(const std::string& input) {
if (strategy_) {
return strategy_(input);
}
return input;
}
private:
Strategy strategy_;
};
// 使用lambda表达式作为策略
processor.setStrategy([](const std::string& input) {
std::string result = input;
std::reverse(result.begin(), result.end());
return result;
});
这种方法更加灵活，特别适合简单的策略逻辑。C++11引入的std::function和lambda表达式让策略模式的实现变得更加简洁。
3.3 策略模式的性能考量
在性能敏感的场景中，策略模式的运行时多态可能会带来一定的开销。如果策略在程序运行期间不会改变，可以考虑使用模板实现的编译时策略模式：
cpp复制template<typename Strategy>
class TextProcessor {
public:
std::string processText(const std::string& input) {
return strategy_.transform(input);
}
private:
Strategy strategy_;
};
// 使用示例
TextProcessor<UpperCaseStrategy> processor;
std::cout << processor.processText("Hello") << std::endl;
这种实现方式在编译时就确定了策略类型，消除了运行时多态的开销，但失去了运行时动态切换策略的能力。
4. 策略模式在实际项目中的经验分享
经过多年C++开发实践，我总结了以下关于策略模式的使用经验和注意事项。
4.1 策略对象的生命周期管理
在C++中，策略对象的生命周期管理尤为重要。我推荐以下几种管理方式：
-
unique_ptr所有权转移（推荐）：
cpp复制context.setStrategy(std::make_unique<ConcreteStrategy>());这种方式清晰表达了所有权转移，策略对象由上下文接管生命周期。
-
共享所有权（shared_ptr）：
cpp复制context.setStrategy(std::make_shared<ConcreteStrategy>());当多个上下文需要共享同一个策略实例时使用。
-
引用或指针（需谨慎）：
cpp复制ConcreteStrategy strategy; context.setStrategy(&strategy);必须确保策略对象的生命周期长于上下文对象。
注意：绝对不要将局部变量的地址传递给策略上下文，这会导致悬垂指针问题。
4.2 策略模式的测试策略
策略模式的一个巨大优势是便于单元测试。我们可以为每个策略编写独立的测试用例，也可以为上下文类注入mock策略进行测试：
cpp复制// 测试用mock策略
class MockStrategy : public TextTransformStrategy {
public:
MOCK_METHOD(std::string, transform, (const std::string&), (const override));
};
TEST(TextProcessorTest, ProcessTextDelegatesToStrategy) {
TextProcessor processor;
auto mockStrategy = std::make_unique<MockStrategy>();
auto& strategyRef = *mockStrategy;
processor.setStrategy(std::move(mockStrategy));
EXPECT_CALL(strategyRef, transform("test"))
.WillOnce(Return("mock result"));
ASSERT_EQ("mock result", processor.processText("test"));
}
4.3 策略模式与其它模式的结合
策略模式常与其他设计模式配合使用：
- 策略+工厂模式：如前所述，用工厂管理策略创建。
- 策略+组合模式：构建策略的层次结构，实现复杂策略逻辑。
- 策略+装饰模式：动态添加策略的附加功能。
- 策略+模板方法模式：在算法骨架中使用策略实现可变步骤。
例如，在游戏AI中，我们可能有一个基础AI策略，然后通过装饰模式为其添加特殊能力或行为修改。
4.4 常见陷阱与解决方案
-
策略膨胀问题：当策略类过多时，可以考虑：
- 使用策略组合（一个策略包含其他策略）
- 引入策略的层次结构（基策略、派生策略）
- 考虑是否真的需要这么多策略，能否合并
-
策略间共享状态：如果策略需要共享数据：
- 通过上下文类传递共享数据
- 使用单例或服务定位器模式（谨慎使用）
- 将共享数据作为策略方法的参数
-
策略选择逻辑复杂：当策略选择逻辑变得复杂时：
- 引入策略工厂或策略选择器类
- 考虑使用规则引擎或决策表
- 将选择逻辑配置化（如从配置文件读取）
5. 策略模式在现代C++中的演进
随着C++标准的更新，策略模式的实现方式也在不断演进。下面介绍几种现代C++中的新实现方式。
5.1 使用std::variant实现类型安全策略
C++17引入的std::variant可以实现类型安全的策略模式：
cpp复制using Strategy = std::variant<UpperCaseStrategy, LowerCaseStrategy, CapitalizeStrategy>;
class TextProcessor {
public:
void setStrategy(Strategy strategy) {
strategy_ = std::move(strategy);
}
std::string processText(const std::string& input) {
return std::visit([&](auto&& strategy) {
return strategy.transform(input);
}, strategy_);
}
private:
Strategy strategy_;
};
这种方法在编译时就能检查所有可能的策略类型，避免了运行时动态类型检查的开销。
5.2 使用concepts约束策略类型
C++20引入了concepts，我们可以用它来约束策略类型：
cpp复制template<typename T>
concept TextTransformStrategy = requires(T t, const std::string& s) {
{ t.transform(s) } -> std::convertible_to<std::string>;
};
template<TextTransformStrategy Strategy>
class TextProcessor {
public:
std::string processText(const std::string& input) {
return strategy_.transform(input);
}
void setStrategy(Strategy newStrategy) {
strategy_ = std::move(newStrategy);
}
private:
Strategy strategy_;
};
这种方式在编译时就能确保传入的策略类型符合接口要求，提供了更好的类型安全性。
5.3 策略模式与协程结合
C++20引入了协程，我们可以利用协程来实现异步策略模式：
cpp复制class AsyncTextTransformStrategy {
public:
virtual ~AsyncTextTransformStrategy() = default;
virtual std::future<std::string> transformAsync(const std::string& input) const = 0;
};
class AsyncUpperCaseStrategy : public AsyncTextTransformStrategy {
public:
std::future<std::string> transformAsync(const std::string& input) const override {
co_return toUpper(input); // 假设toUpper是一个耗时操作
}
};
class AsyncTextProcessor {
public:
std::future<std::string> processTextAsync(const std::string& input) {
if (strategy_) {
co_return co_await strategy_->transformAsync(input);
}
co_return input;
}
private:
std::unique_ptr<AsyncTextTransformStrategy> strategy_;
};
这种实现方式特别适合I/O密集型或计算密集型的策略操作。