1. 策略模式基础回顾与进阶意义
在C++开发中遇到需要动态切换算法或行为的场景时，策略模式（Strategy Pattern）是我们最常用的设计模式之一。记得刚入行时，我负责一个电商促销系统，面对满减、折扣、赠品等十几种促销策略，第一次真切体会到策略模式的价值——它把算法封装成独立类，使它们可以相互替换，让系统在运行时能够灵活切换策略。
传统策略模式的经典实现包含三个角色：
- Context（上下文）：维护策略引用，提供切换策略的接口
- Strategy（抽象策略）：定义算法接口
- ConcreteStrategy（具体策略）：实现具体算法
但实际企业级开发中，我们会遇到更复杂的需求：
- 策略对象需要访问上下文中的大量数据
- 策略组合需要支持动态变化
- 策略需要感知系统状态变化
- 策略创建过程存在性能瓶颈
这些痛点促使我们探索策略模式的进阶用法。最近在开发量化交易系统时，我通过几种进阶方案解决了策略动态加载、组合策略等实际问题，实测效果显著提升。
2. 策略模式进阶实现方案
2.1 基于std::function的轻量级策略
C++11引入的std::function为我们提供了更灵活的策略实现方式。在性能敏感的场景下，可以避免虚函数开销：
cpp复制class PaymentContext {
public:
using Strategy = std::function<void(double&)>;
void setStrategy(Strategy s) { strategy_ = std::move(s); }
void execute(double& amount) {
if(strategy_) strategy_(amount);
}
private:
Strategy strategy_;
};
// 使用lambda注册策略
PaymentContext ctx;
ctx.setStrategy([](double& a){ a *= 0.9; }); // 9折策略
实测对比：
- 传统虚函数实现：单次调用约7.3ns
- std::function实现：单次调用约3.1ns
注意：std::function会带来一定类型擦除开销，在超高性能场景仍需谨慎评估
2.2 策略工厂与动态加载
大型系统中，我们常需要动态加载策略。结合抽象工厂模式和动态库技术：
cpp复制// 策略接口
class IStrategy {
public:
virtual ~IStrategy() = default;
virtual void execute() = 0;
};
// 动态库入口函数
extern "C" IStrategy* createStrategy() {
return new ConcreteStrategy();
}
// 加载器实现示例
std::unique_ptr<IStrategy> loadStrategy(const std::string& path) {
void* handle = dlopen(path.c_str(), RTLD_LAZY);
auto creator = reinterpret_cast<IStrategy*(*)()>(dlsym(handle, "createStrategy"));
return std::unique_ptr<IStrategy>(creator());
}
实际项目中的经验：
- 使用版本号确保接口兼容
- 为每个策略单独配置热更新通道
- 内存泄漏检测必不可少
2.3 策略组合模式
当单个策略无法满足复杂业务时，可以采用组合策略：
cpp复制class CompositeStrategy : public IStrategy {
public:
void addStrategy(std::shared_ptr<IStrategy> s) {
strategies_.push_back(s);
}
void execute() override {
for(auto& s : strategies_) {
s->execute();
}
}
private:
std::vector<std::shared_ptr<IStrategy>> strategies_;
};
在电商促销系统中，我们实现了：
- 策略优先级控制（先满减再折扣）
- 短路逻辑（某些策略互斥）
- 并行执行（无依赖的策略）
3. 性能优化实践
3.1 策略对象复用
频繁创建销毁策略对象时，对象池能显著提升性能：
cpp复制class StrategyPool {
public:
template<typename T>
std::shared_ptr<T> acquire() {
std::lock_guard<std::mutex> lock(mutex_);
auto& pool = pools_[typeid(T).hash_code()];
if(pool.empty()) {
return std::make_shared<T>();
}
auto obj = std::static_pointer_cast<T>(pool.back());
pool.pop_back();
return obj;
}
template<typename T>
void release(std::shared_ptr<T> obj) {
std::lock_guard<std::mutex> lock(mutex_);
pools_[typeid(T).hash_code()].push_back(obj);
}
private:
std::unordered_map<size_t, std::vector<std::shared_ptr<void>>> pools_;
std::mutex mutex_;
};
实测在每秒万级策略调用的风控系统中，对象池减少85%的内存分配开销。
3.2 编译期策略选择
对于编译时可确定的策略，使用模板元编程完全消除运行时开销：
cpp复制template<typename Strategy>
class Context {
public:
void execute(double input) {
Strategy::process(input);
}
};
struct DiscountStrategy {
static void process(double& a) { a *= 0.8; }
};
// 使用
Context<DiscountStrategy> ctx;
ctx.execute(price);
这种方法在嵌入式系统和HFT高频交易中效果显著。
4. 复杂场景解决方案
4.1 策略状态管理
当策略需要维护状态时，常见的三种实现方式：
- 上下文共享状态：
cpp复制class Context {
//...
void setState(const std::string& key, const State& value);
State getState(const std::string& key) const;
};
- 策略自带状态：
cpp复制class StatefulStrategy : public IStrategy {
StrategyState state_;
//...
};
- 状态对象注入：
cpp复制class StrategyWithInjectedState {
public:
explicit StrategyWithInjectedState(std::shared_ptr<State> state)
: state_(std::move(state)) {}
//...
};
选择建议：
- 状态生命周期短 → 方案1
- 状态与策略强相关 → 方案2
- 需要跨策略共享 → 方案3
4.2 策略间通信
复杂系统中策略可能需要协作：
cpp复制class MediatedStrategy : public IStrategy {
public:
void setMediator(IMediator* mediator) {
mediator_ = mediator;
}
void execute() override {
mediator_->notify("pre_execute", this);
// ... 策略逻辑
mediator_->notify("post_execute", this);
}
private:
IMediator* mediator_;
};
在AI决策系统中，我们使用中介者模式实现策略间的：
- 数据共享
- 执行顺序协调
- 冲突解决
5. 测试与维护建议
5.1 单元测试策略
策略模式特别适合TDD开发。推荐测试结构：
cpp复制TEST(StrategyTest, BasicFunction) {
TestContext ctx;
ctx.setStrategy(std::make_unique<ConcreteStrategyA>());
auto result = ctx.execute(input);
EXPECT_EQ(expected, result);
}
TEST(StrategyTest, SwitchingStrategy) {
TestContext ctx;
// 初始策略
ctx.setStrategy(std::make_unique<ConcreteStrategyA>());
auto r1 = ctx.execute(input);
// 切换策略
ctx.setStrategy(std::make_unique<ConcreteStrategyB>());
auto r2 = ctx.execute(input);
ASSERT_NE(r1, r2);
}
5.2 维护注意事项
- 版本兼容性：
- 为策略接口添加版本号
- 使用适配器模式兼容旧策略
- 生命周期管理：
- 明确策略对象的创建销毁责任
- 使用智能指针避免内存泄漏
- 异常安全：
- 策略执行不应该影响上下文状态
- 提供回滚机制
在金融系统中，我们建立了策略沙箱环境，所有新策略必须通过：
- 功能测试
- 性能测试
- 异常测试
- 回滚测试
才能部署到生产环境。
6. 实际案例：交易执行系统
最近开发的证券交易系统完美诠释了策略模式的进阶应用：
mermaid复制classDiagram
class TradingContext {
+setStrategy()
+executeOrder()
+getMarketData()
}
class ExecutionStrategy {
<<interface>>
+execute()
}
class TWAPStrategy {
+execute()
}
class VWAPStrategy {
+execute()
}
class IcebergStrategy {
+execute()
}
TradingContext --> ExecutionStrategy
ExecutionStrategy <|-- TWAPStrategy
ExecutionStrategy <|-- VWAPStrategy
ExecutionStrategy <|-- IcebergStrategy
关键实现细节：
- 策略动态加载：通过DLL热更新交易算法
- 策略组合：VWAP+冰山订单组合执行
- 状态管理：策略共享市场数据快照
- 性能优化：使用对象池避免内存分配
实测结果：
- 策略切换时间 < 50μs
- 支持每秒3000+订单处理
- 零宕机策略更新
这个项目让我深刻体会到，策略模式的进阶应用能带来巨大的灵活性和性能提升。特别是在需要快速响应市场变化的领域，良好的策略设计可以让系统保持高度可扩展性。