三亩地 三亩地SAN MU DI · CODE DIARY
交流投稿
ARTICLE DETAIL

日记详情

真实记录编程学习的某一天，欢迎挑你感兴趣的翻一翻。

首页/学习日记/日记详情

C++策略模式进阶：现代实现与工程实践

发布时间：2026/8/9 16:00:50 三亩地 编程学习日记
C++策略模式进阶：现代实现与工程实践

1. 策略模式基础回顾与进阶必要性

在C++开发中，策略模式(Strategy Pattern)是我们最常用的设计模式之一。它定义了算法家族，分别封装起来，让它们之间可以互相替换。这种模式让算法的变化独立于使用算法的客户。但很多开发者停留在基础的"用接口定义策略"阶段，实际上策略模式在工程实践中有着更丰富的应用场景和优化空间。

我经历过一个游戏AI项目，角色行为策略最初采用简单if-else实现，随着策略数量增加到20+，代码变得难以维护。重构为策略模式后，不仅解决了维护性问题，还意外获得了运行时动态切换策略的能力。这个经历让我意识到，策略模式的价值远不止于教科书上的示例。

2. 策略模式的C++实现进阶技巧

2.1 现代C++中的策略实现选择

传统策略模式常通过抽象基类和继承体系实现。在现代C++中，我们有了更多选择：

// 传统面向对象实现 class SortingStrategy { public: virtual void sort(vector<int>& data) = 0; }; // 现代C++函数对象实现 using SortingStrategy = std::function<void(vector<int>&)>; // 模板策略实现 template<typename Strategy> class Sorter { Strategy strategy; public: void sort(vector<int>& data) { strategy(data); } };

三种实现各有优劣：

  1. 面向对象实现：符合经典设计模式，支持运行时多态
  2. 函数对象：更灵活，可以接受lambda表达式
  3. 模板策略：零成本抽象，编译期多态

实际项目中，我推荐混合使用这些方法。对性能敏感的核心算法用模板策略，需要运行时动态切换的策略用函数对象。

2.2 策略的创建与管理

随着项目规模扩大，策略对象的创建和管理成为挑战。我总结了几种实用模式：

  1. 策略工厂模式：
class StrategyFactory { public: static std::unique_ptr<Strategy> create(const string& type) { if (type == "A") return make_unique<StrategyA>(); if (type == "B") return make_unique<StrategyB>(); throw invalid_argument("Unknown strategy type"); } };
  1. 策略注册表模式：
class StrategyRegistry { static unordered_map<string, function<unique_ptr<Strategy>()>> creators; public: static void registerStrategy(const string& name, auto creator) { creators[name] = creator; } static unique_ptr<Strategy> create(const string& name) { return creators.at(name)(); } };
  1. 策略缓存与重用：
class StrategyCache { unordered_map<string, shared_ptr<Strategy>> cache; public: shared_ptr<Strategy> get(const string& type) { if (!cache.count(type)) { cache[type] = StrategyFactory::create(type); } return cache[type]; } };

3. 策略模式在复杂系统中的应用

3.1 多维度策略组合

在实际工程中，单一策略维度往往不够。比如游戏AI需要同时考虑移动策略和攻击策略。我常用两种处理方式：

  1. 策略组合模式：
class CompositeStrategy { shared_ptr<MoveStrategy> moveStrategy; shared_ptr<AttackStrategy> attackStrategy; public: void execute(Character& c) { moveStrategy->move(c); attackStrategy->attack(c); } };
  1. 策略优先级系统：
class PriorityStrategy { vector<shared_ptr<Strategy>> strategies; public: void addStrategy(shared_ptr<Strategy> s, int priority) { strategies.emplace(priority, s); } void execute() { for (auto& [_, s] : strategies) { if (s->shouldExecute()) { s->execute(); break; } } } };

3.2 策略的动态切换与过渡

平滑的策略切换能显著提升用户体验。在我的游戏项目中，实现了以下技术：

  1. 策略过渡混合：
class BlendingStrategy : public Strategy { shared_ptr<Strategy> from, to; float blendFactor = 0; public: void update() override { blendFactor += 0.1f; if (blendFactor >= 1.0f) { // 切换完成 } } void execute() override { auto resultFrom = from->evaluate(); auto resultTo = to->evaluate(); auto finalResult = lerp(resultFrom, resultTo, blendFactor); // 应用混合结果 } };
  1. 策略历史堆栈：
class StrategyStack { stack<shared_ptr<Strategy>> stack; public: void push(shared_ptr<Strategy> s) { if (!stack.empty()) { stack.top()->onPause(); } stack.push(s); s->onEnter(); } void pop() { if (!stack.empty()) { stack.top()->onExit(); stack.pop(); if (!stack.empty()) { stack.top()->onResume(); } } } };

4. 策略模式的性能优化

4.1 内存与缓存优化

在性能敏感场景，我采用以下优化手段：

  1. 策略内存池：
class StrategyPool { unordered_map<type_index, vector<unique_ptr<Strategy>>> pools; public: template<typename T> T* acquire() { auto& pool = pools[typeid(T)]; if (pool.empty()) { pool.push_back(make_unique<T>()); } auto ptr = pool.back().release(); pool.pop_back(); return static_cast<T*>(ptr); } template<typename T> void release(T* ptr) { pools[typeid(T)].emplace_back(ptr); } };
  1. 策略数据局部性优化：
class HotColdStrategy { struct ColdData { // 不常访问的数据 }; struct HotData { // 高频访问的数据 }; unique_ptr<ColdData> cold; HotData hot; };

4.2 编译期策略选择

对于编译期已知的策略，使用模板可以消除运行时开销：

template<typename Strategy> class Context { Strategy strategy; public: void execute() { strategy.doAlgorithm(); } }; // 使用 Context<QuickSortStrategy> context; context.execute();

结合C++20概念(concepts)可以做得更好：

template<typename T> concept SortingStrategy = requires(T t, vector<int>& v) { { t.sort(v) } -> same_as<void>; }; template<SortingStrategy Strategy> class Sorter { // ... };

5. 策略模式的测试与调试

5.1 策略的单元测试

为策略编写有效的测试用例：

TEST(StrategyTest, BubbleSortTest) { vector<int> data = {3,1,4,2}; BubbleSortStrategy strategy; strategy.sort(data); ASSERT_EQ(vector<int>{1,2,3,4}, data); } TEST(StrategyTest, StrategySwitchTest) { Context context(make_unique<StrategyA>()); context.execute(); context.setStrategy(make_unique<StrategyB>()); context.execute(); // 验证行为变化 }

5.2 策略的调试技巧

  1. 策略日志记录：
class LoggingStrategyDecorator : public Strategy { shared_ptr<Strategy> wrapped; Logger& logger; public: void execute() override { logger.log("Executing strategy"); auto start = chrono::high_resolution_clock::now(); wrapped->execute(); auto end = chrono::high_resolution_clock::now(); logger.log("Strategy completed in " + to_string(chrono::duration_cast<milliseconds>(end-start).count()) + "ms"); } };
  1. 策略可视化调试：
class DebuggableStrategy : public Strategy { public: virtual void debugDraw() = 0; }; void debugRender() { for (auto& strategy : activeStrategies) { strategy->debugDraw(); } }

6. 策略模式在大型项目中的架构实践

6.1 策略的依赖管理

在复杂系统中，策略可能需要访问各种服务。我常用依赖注入：

class TradingStrategy { MarketDataService& marketData; OrderService& orderService; public: TradingStrategy(MarketDataService& mds, OrderService& os) : marketData(mds), orderService(os) {} void execute() { auto data = marketData.getLatest(); // 使用data生成订单 orderService.submit(order); } };

6.2 策略的配置化

通过JSON等配置文件定义策略行为：

{ "strategies": { "aggressive": { "type": "TradingStrategy", "params": { "riskLevel": "high", "maxPosition": 0.3 } } } }

对应的加载代码：

shared_ptr<Strategy> loadStrategy(const json& config) { auto type = config["type"]; if (type == "TradingStrategy") { return make_shared<TradingStrategy>( config["params"]["riskLevel"], config["params"]["maxPosition"] ); } // ... }

7. 策略模式与其他模式的结合

7.1 策略与状态模式的异同

策略和状态模式结构相似但意图不同：

  • 策略模式：客户端主动选择算法
  • 状态模式：状态转换由内部条件决定

我有时会结合两者：

class HybridStateStrategy { shared_ptr<State> currentState; shared_ptr<Strategy> currentStrategy; void update() { // 状态逻辑决定策略选择 currentStrategy = currentState->selectStrategy(); currentStrategy->execute(); } };

7.2 策略与命令模式的协同

策略模式定义算法，命令模式封装请求：

class CommandStrategyAdapter : public Command { shared_ptr<Strategy> strategy; public: void execute() override { strategy->execute(); } };

这种组合在实现撤销/重做功能时特别有用。

8. 策略模式的现代C++演进

8.1 使用std::variant实现策略模式

C++17引入的variant提供了新思路：

using Strategy = variant<StrategyA, StrategyB, StrategyC>; class Context { Strategy strategy; public: void execute() { visit([](auto&& s) { s.execute(); }, strategy); } };

8.2 策略模式与协程结合

C++20协程为策略模式带来新可能：

task<void> CoroutineStrategy::executeAsync() { while (!done) { auto data = co_await fetchDataAsync(); process(data); co_await delay(100ms); } }

9. 策略模式的反模式与陷阱

9.1 过度设计警告

不是所有情况都需要策略模式。当遇到以下情况时，可能需要重新考虑：

  • 只有1-2种简单算法变体
  • 策略之间差异极小
  • 策略很少变化

9.2 性能陷阱

动态策略的虚函数调用可能有开销。在性能关键路径上，考虑：

  • 使用模板策略
  • 将策略逻辑移出热循环
  • 使用策略数据预计算

10. 实战案例：游戏AI策略系统

分享一个实际游戏项目中的策略系统架构：

class AICharacter { StrategyStack strategyStack; Blackboard sharedData; void update() { auto currentStrategy = strategyStack.top(); currentStrategy->evaluate(sharedData); currentStrategy->execute(sharedData); } }; class CombatStrategy : public Strategy { void evaluate(Blackboard& bb) override { if (bb.get<float>("health") < 0.3f) { bb.set("shouldEscape", true); } } void execute(Blackboard& bb) override { if (bb.get<bool>("shouldEscape")) { // 执行逃跑逻辑 } else { // 执行攻击逻辑 } } };

这个系统支持：

  • 策略优先级
  • 策略中断
  • 策略间数据共享
  • 动态策略调整

在项目中，我们通过这套架构管理了超过50种AI行为策略，支持了复杂的NPC行为逻辑。

编程学习 学习日记 实战经验
← 返回列表