C++策略模式实战：算法封装与动态切换

1. 策略模式在C++中的实战应用

作为一名长期奋战在C++开发一线的程序员，我发现在处理复杂业务逻辑时，策略模式（Strategy Pattern）是最实用但最容易被低估的设计模式之一。它完美解决了算法族切换和运行时行为变更的痛点，特别是在游戏开发、金融计算等需要频繁调整计算策略的场景中。

2. 策略模式核心原理剖析

2.1 模式定义与UML结构

策略模式属于行为型设计模式，其核心思想是将算法封装成独立的策略类，使它们可以相互替换。标准UML结构包含：

• Context：持有一个策略引用的环境类
• Strategy：抽象策略接口
• ConcreteStrategy：具体策略实现

在C++中，我们通常使用抽象类或纯虚函数作为策略接口。不同于简单的函数指针，策略模式提供了完整的面向对象封装能力。

2.2 典型应用场景分析

根据我的项目经验，以下场景特别适合采用策略模式：

1. 支付系统：多种支付方式（信用卡、支付宝、微信）的切换
2. 游戏AI：不同难度级别的敌人行为算法
3. 数据处理：多种排序/过滤算法的动态选择
4. 报价系统：会员等级对应的不同折扣策略

3. C++实现方案详解

3.1 基础实现模板

cpp复制// 策略接口
class SortingStrategy {
public:
    virtual void sort(vector<int>& data) = 0;
    virtual ~SortingStrategy() = default;
};

// 具体策略
class QuickSort : public SortingStrategy {
    void sort(vector<int>& data) override {
        // 快速排序实现
    }
};

class MergeSort : public SortingStrategy {
    void sort(vector<int>& data) override {
        // 归并排序实现
    }
};

// 上下文环境
class SortContext {
    unique_ptr<SortingStrategy> strategy;
public:
    void setStrategy(unique_ptr<SortingStrategy> s) {
        strategy = move(s);
    }
    
    void executeSort(vector<int>& data) {
        if(strategy) strategy->sort(data);
    }
};

3.2 现代C++优化技巧

1. 使用std::function替代接口类：

cpp复制using SortStrategy = function<void(vector<int>&)>;

class SortContext {
    SortStrategy strategy;
public:
    void setStrategy(SortStrategy s) {
        strategy = s;
    }
    //...其余实现
};

2. 结合模板的编译期策略选择：

cpp复制template<typename Strategy>
class SortContext {
    Strategy strategy;
public:
    void sort(vector<int>& data) {
        strategy.sort(data);
    }
};

4. 实战案例：游戏伤害计算系统

4.1 需求背景

在MMORPG开发中，不同职业（战士、法师、射手）需要采用不同的伤害计算公式，且可能随版本更新调整算法。

4.2 具体实现

cpp复制// 伤害计算策略接口
class DamageCalculator {
public:
    virtual int calculate(Character& attacker, Character& target) = 0;
};

// 具体策略
class WarriorDamage : public DamageCalculator {
    int calculate(Character& a, Character& t) override {
        return a.strength * 2 - t.armor;
    }
};

class MageDamage : public DamageCalculator {
    int calculate(Character& a, Character& t) override {
        return a.intelligence * 3 - t.magicResist;
    }
};

// 战斗上下文
class CombatSystem {
    unique_ptr<DamageCalculator> calculator;
public:
    void setCalculator(unique_ptr<DamageCalculator> calc) {
        calculator = move(calc);
    }
    
    int performAttack(Character& a, Character& t) {
        return calculator->calculate(a, t);
    }
};

5. 性能优化与陷阱规避

5.1 内存管理要点

1. 优先使用unique_ptr管理策略对象生命周期
2. 避免在热代码路径中频繁创建/销毁策略对象
3. 考虑对象池模式复用策略实例

5.2 多线程注意事项

• 策略类应设计为无状态（stateless）
• 共享策略对象需要保证线程安全
• 上下文切换策略时需要适当同步

关键提示：在性能敏感场景，编译期策略（通过模板实现）通常比运行时策略快5-10倍

6. 策略模式与其他模式的协作

6.1 与工厂模式结合

通过工厂创建具体策略对象，实现更灵活的策略配置：

cpp复制class StrategyFactory {
public:
    static unique_ptr<DamageCalculator> create(string_view type) {
        if(type == "warrior") return make_unique<WarriorDamage>();
        if(type == "mage") return make_unique<MageDamage>();
        throw invalid_argument("Unknown strategy type");
    }
};

6.2 与状态模式对比

• 策略模式：算法/行为的外部切换
• 状态模式：对象内部状态的转换
  两者经常被混淆，但意图不同。策略模式关注的是"怎么做"，状态模式关注的是"是什么"。

7. 测试策略模式的正确姿势

7.1 单元测试要点

1. 为每个具体策略编写独立测试用例
2. 验证上下文类能否正确调用当前策略
3. 测试策略切换后的行为变化

7.2 Mock测试示例

cpp复制TEST(CombatSystemTest, ShouldUseCurrentStrategy) {
    MockDamageCalculator mock;
    CombatSystem system;
    system.setCalculator(make_unique<MockDamageCalculator>());
    
    EXPECT_CALL(mock, calculate(_,_))
        .WillOnce(Return(100));
    
    Character a, t;
    ASSERT_EQ(100, system.performAttack(a,t));
}

8. 实际项目中的经验总结

在最近一个交易引擎项目中，我们使用策略模式实现了多种价格计算算法。几点深刻体会：

1. 策略接口设计要足够抽象，但不要过度设计
2. 策略对象的创建成本需要考虑，特别是高频交易场景
3. 配置文件驱动策略选择比硬编码更易维护
4. 策略模式与依赖注入框架（如Boost.DI）结合效果极佳

一个常见的反模式是将策略类设计得过于庞大。理想情况下，每个策略应该只关注单一算法。当发现策略类超过300行代码时，就需要考虑是否违反了单一职责原则。