C++策略模式：核心原理与实战应用

1. 策略模式在C++中的核心价值

策略模式（Strategy Pattern）是我在多年C++开发中最常使用的设计模式之一。它的本质是将算法家族封装起来，让它们之间可以互相替换。这种模式让算法的变化独立于使用算法的客户。

想象你正在开发一个电商系统，需要实现不同的折扣策略：新用户首单优惠、会员折扣、满减活动等。如果把这些折扣算法硬编码到订单类中，每次新增折扣类型都需要修改订单类——这明显违反了开闭原则。策略模式通过将每个折扣算法封装成独立类，完美解决了这个问题。

在C++中实现策略模式有三大优势：

1. 运行时灵活性：可以动态切换算法实现，比如根据用户类型实时更换折扣策略
2. 代码解耦：算法实现与使用方完全分离，符合单一职责原则
3. 可测试性：每个策略可以独立测试，mock策略也很容易实现

2. 策略模式的经典实现结构

让我们通过一个完整的C++实现来解剖策略模式的各个组件。这个例子实现了字符串处理的两种策略：正常排序和逆序排序。

2.1 策略接口定义

首先定义策略接口，这是所有具体策略的契约：

cpp复制class Strategy {
public:
    virtual ~Strategy() = default;
    virtual std::string doAlgorithm(std::string_view data) const = 0;
};

这个纯虚类规定了所有具体策略必须实现doAlgorithm方法。注意这里使用了：

• std::string_view：C++17引入的字符串视图，避免不必要的拷贝
• const限定符：表明算法不会修改对象状态
• virtual析构函数：确保通过基类指针删除派生类对象时正确调用析构函数

2.2 具体策略实现

下面是两个具体策略的实现：

cpp复制class NormalSortStrategy : public Strategy {
public:
    std::string doAlgorithm(std::string_view data) const override {
        std::string result(data);
        std::sort(result.begin(), result.end());
        return result;
    }
};

class ReverseSortStrategy : public Strategy {
public:
    std::string doAlgorithm(std::string_view data) const override {
        std::string result(data);
        std::sort(result.begin(), result.end(), std::greater<>());
        return result;
    }
};

关键点：

• 每个策略类只关注自己的算法实现
• 都继承自Strategy接口，保证可以互换
• 使用STL的sort算法实现排序逻辑

2.3 上下文类设计

上下文类是策略的使用者，它持有策略对象的指针：

cpp复制class TextProcessor {
    std::unique_ptr<Strategy> strategy_;
public:
    explicit TextProcessor(std::unique_ptr<Strategy> strategy = nullptr) 
        : strategy_(std::move(strategy)) {}
    
    void setStrategy(std::unique_ptr<Strategy> strategy) {
        strategy_ = std::move(strategy);
    }
    
    void processText(const std::string& text) const {
        if(strategy_) {
            std::cout << "Processing text with strategy: ";
            auto result = strategy_->doAlgorithm(text);
            std::cout << result << "\n";
        } else {
            std::cout << "No strategy set\n";
        }
    }
};

这里有几个值得注意的C++特性：

• 使用unique_ptr管理策略对象生命周期
• 移动语义（std::move）避免不必要的拷贝
• 明确的nullptr检查确保健壮性

3. 策略模式的高级应用技巧

在实际项目中，策略模式的应用远比基础示例复杂。下面分享几个实战中的进阶技巧。

3.1 策略工厂模式

当策略对象创建逻辑复杂时，可以结合工厂模式：

cpp复制class StrategyFactory {
public:
    static std::unique_ptr<Strategy> create(StrategyType type) {
        switch(type) {
            case StrategyType::Normal:
                return std::make_unique<NormalSortStrategy>();
            case StrategyType::Reverse:
                return std::make_unique<ReverseSortStrategy>();
            default:
                throw std::invalid_argument("Unknown strategy type");
        }
    }
};

这样客户端代码可以简化为：

cpp复制auto processor = TextProcessor(StrategyFactory::create(StrategyType::Normal));

3.2 策略与模板的结合

C++的模板元编程可以与策略模式完美结合：

cpp复制template<typename Strategy>
class GenericTextProcessor {
    Strategy strategy;
public:
    void processText(const std::string& text) const {
        auto result = strategy.doAlgorithm(text);
        std::cout << result << "\n";
    }
};

这种编译期策略选择在性能敏感场景特别有用。

3.3 策略的内存管理优化

频繁创建销毁策略对象时，可以考虑对象池：

cpp复制class StrategyPool {
    std::unordered_map<StrategyType, std::shared_ptr<Strategy>> pool_;
public:
    std::shared_ptr<Strategy> get(StrategyType type) {
        if(!pool_.count(type)) {
            pool_[type] = StrategyFactory::create(type);
        }
        return pool_[type];
    }
};

4. 实战中的陷阱与解决方案

即使策略模式看似简单，实际应用中仍会遇到各种问题。以下是几个常见坑点及解决方案。

4.1 策略状态管理

如果策略需要维护状态，要特别注意线程安全问题：

cpp复制class CountingStrategy : public Strategy {
    mutable std::atomic<int> count_{0};
public:
    std::string doAlgorithm(std::string_view data) const override {
        count_++;
        // ...算法实现
    }
    
    int getCount() const { return count_; }
};

使用atomic确保计数器线程安全。

4.2 策略接口演化

当需要新增策略方法时，避免修改现有接口：

cpp复制class ExtendedStrategy : public Strategy {
public:
    virtual void preProcess(std::string& data) const {}
    virtual void postProcess(std::string& data) const {}
};

通过继承扩展而非修改基类，符合开闭原则。

4.3 性能考量

虚函数调用有一定开销，在极端性能场景可以考虑：

1. 策略模板化（如前文所示）
2. CRTP模式（奇异递归模板模式）
3. 函数指针替代虚函数

cpp复制using StrategyFunc = std::string(*)(std::string_view);

class FunctionPointerProcessor {
    StrategyFunc strategy_;
public:
    explicit FunctionPointerProcessor(StrategyFunc strategy) 
        : strategy_(strategy) {}
    
    void process(const std::string& text) {
        auto result = strategy_(text);
        // ...
    }
};

5. 真实项目案例：支付系统策略实现

让我们看一个电商支付系统的实际案例。系统需要支持多种支付方式：信用卡、支付宝、微信支付等。

5.1 支付策略接口

cpp复制class PaymentStrategy {
public:
    virtual ~PaymentStrategy() = default;
    virtual bool pay(double amount) const = 0;
    virtual std::string getName() const = 0;
};

5.2 具体支付策略

cpp复制class CreditCardPayment : public PaymentStrategy {
    std::string cardNumber_;
    std::string expiryDate_;
    std::string cvv_;
public:
    CreditCardPayment(std::string card, std::string expiry, std::string cvv)
        : cardNumber_(std::move(card))
        , expiryDate_(std::move(expiry)) 
        , cvv_(std::move(cvv)) {}
    
    bool pay(double amount) const override {
        // 调用支付网关API
        std::cout << "Processing $" << amount << " via credit card\n";
        return true;
    }
    
    std::string getName() const override {
        return "Credit Card";
    }
};

// 类似实现AlipayPayment、WeChatPayment等

5.3 支付上下文

cpp复制class PaymentProcessor {
    std::unique_ptr<PaymentStrategy> strategy_;
public:
    void setStrategy(std::unique_ptr<PaymentStrategy> strategy) {
        strategy_ = std::move(strategy);
    }
    
    bool executePayment(double amount) {
        if(!strategy_) {
            throw std::runtime_error("Payment strategy not set");
        }
        
        std::cout << "Using " << strategy_->getName() << "\n";
        return strategy_->pay(amount);
    }
};

5.4 客户端代码

cpp复制PaymentProcessor processor;
processor.setStrategy(std::make_unique<CreditCardPayment>("1234-5678", "12/25", "123"));
processor.executePayment(99.99);

// 运行时切换策略
processor.setStrategy(std::make_unique<AlipayPayment>("user@example.com"));
processor.executePayment(49.99);

这个案例展示了策略模式在实际业务中的典型应用，支付方式的增减完全不影响支付处理器的主要逻辑。

6. 策略模式与其他模式的关系

理解策略模式与其他模式的区别和联系，能帮助我们在设计时做出更合适的选择。

6.1 策略 vs 工厂模式

• 工厂模式：关注对象创建
• 策略模式：关注行为封装

它们经常一起使用，如前面的策略工厂示例。

6.2 策略 vs 模板方法模式

• 模板方法：在父类定义算法骨架，子类实现特定步骤
• 策略：完全替换整个算法

模板方法使用继承，策略使用组合。

6.3 策略 vs 状态模式

• 状态模式：状态改变引起行为改变，状态间通常有转换关系
• 策略模式：策略之间独立，客户端主动选择策略

状态模式更像是策略模式的自动版。

7. C++20下的现代策略模式实现

C++20引入了一些新特性，可以让策略模式实现得更优雅。

7.1 使用concept约束策略

cpp复制template<typename T>
concept StrategyConcept = requires(T s, std::string_view data) {
    { s.doAlgorithm(data) } -> std::convertible_to<std::string>;
};

template<StrategyConcept Strategy>
class ModernTextProcessor {
    Strategy strategy;
public:
    void process(std::string_view text) {
        auto result = strategy.doAlgorithm(text);
        std::cout << result << "\n";
    }
};

7.2 使用std::function作为策略

cpp复制using StringStrategy = std::function<std::string(std::string_view)>;

class FunctionalProcessor {
    StringStrategy strategy_;
public:
    explicit FunctionalProcessor(StringStrategy strategy)
        : strategy_(std::move(strategy)) {}
    
    void process(const std::string& text) {
        auto result = strategy_(text);
        std::cout << result << "\n";
    }
};

// 使用lambda作为策略
FunctionalProcessor processor([](std::string_view data) {
    std::string result(data);
    std::sort(result.begin(), result.end());
    return result;
});

这种方式更加灵活，任何可调用对象都可以作为策略。

7.3 协程与策略模式结合

对于异步操作，策略模式也可以很好地工作：

cpp复制class AsyncStrategy {
public:
    virtual ~AsyncStrategy() = default;
    virtual std::future<std::string> doAlgorithmAsync(std::string_view data) const = 0;
};

class AsyncTextProcessor {
    std::unique_ptr<AsyncStrategy> strategy_;
public:
    void setStrategy(std::unique_ptr<AsyncStrategy> strategy) {
        strategy_ = std::move(strategy);
    }
    
    std::future<void> processAsync(const std::string& text) {
        auto result = co_await strategy_->doAlgorithmAsync(text);
        std::cout << result << "\n";
    }
};

8. 性能测试与优化策略

在实际项目中应用策略模式时，性能是需要考虑的重要因素。下面是一些测试数据和优化建议。

8.1 虚函数调用开销测试

我们对比三种实现方式的性能：

1. 经典虚函数策略
2. 模板策略
3. std::function策略

测试结果（处理100万次，单位ms）：

8.2 优化建议

1. 热点路径：对性能关键代码使用模板策略
2. 动态需求：需要运行时替换时使用虚函数
3. 灵活性优先：策略变化频繁时考虑std::function
4. 内存考虑：对象池复用策略对象减少分配开销

8.3 内联优化技巧

对于模板策略，确保编译器能内联策略调用：

cpp复制template<typename Strategy>
class InlineOptimizedProcessor {
    Strategy strategy;
public:
    __attribute__((always_inline)) 
    void process(const std::string& text) {
        auto result = strategy.doAlgorithm(text);
        // ...
    }
};

使用always_inline提示编译器内联策略调用（GCC/Clang）。

9. 测试策略模式的技巧

良好的测试策略能确保策略模式的正确实现和灵活替换。

9.1 单元测试策略

每个策略应该有自己的测试用例：

cpp复制TEST(NormalSortStrategyTest, SortsStringCorrectly) {
    NormalSortStrategy strategy;
    auto result = strategy.doAlgorithm("dbca");
    EXPECT_EQ(result, "abcd");
}

9.2 模拟策略测试上下文

测试上下文类时使用mock策略：

cpp复制class MockStrategy : public Strategy {
public:
    MOCK_METHOD(std::string, doAlgorithm, (std::string_view), (const, override));
};

TEST(TextProcessorTest, DelegatesToStrategy) {
    auto mock = std::make_unique<MockStrategy>();
    EXPECT_CALL(*mock, doAlgorithm("test")).WillOnce(Return("test"));
    
    TextProcessor processor(std::move(mock));
    processor.processText("test");
}

9.3 性能回归测试

确保策略切换不会引入性能退化：

cpp复制BENCHMARK(TemplateStrategyBenchmark) {
    GenericTextProcessor<NormalSortStrategy> processor;
    for(auto& s : testStrings) {
        processor.processText(s);
    }
}

10. 从设计角度评估策略模式

虽然策略模式很实用，但也不是银弹。下面从设计角度分析其适用场景。

10.1 适用场景

1. 一个系统需要动态地在几种算法中选择一种
2. 有多个条件语句的相同行为，每个分支对应一种算法
3. 算法使用方不需要知道具体实现细节
4. 算法需要独立于使用方变化

10.2 不适用场景

1. 算法很少变化：直接硬编码更简单
2. 客户端必须了解策略实现细节：违背封装原则
3. 只有一两种简单算法：过度设计

10.3 设计质量指标

好的策略模式实现应该：

1. 客户端代码不依赖具体策略类
2. 策略接口保持稳定
3. 新增策略不影响现有代码
4. 策略之间完全独立

11. 跨平台开发中的策略模式

在跨平台C++项目中，策略模式特别有用。例如处理不同平台的UI渲染。

11.1 平台渲染策略

cpp复制class RenderStrategy {
public:
    virtual void drawButton(float x, float y, float w, float h, const std::string& text) = 0;
    virtual void drawWindow(float x, float y, float w, float h) = 0;
};

class WindowsRenderStrategy : public RenderStrategy {
    // 实现Windows特定渲染
};

class MacRenderStrategy : public RenderStrategy {
    // 实现Mac特定渲染
};

11.2 自动平台检测

cpp复制std::unique_ptr<RenderStrategy> createPlatformRenderer() {
    #ifdef _WIN32
        return std::make_unique<WindowsRenderStrategy>();
    #elif __APPLE__
        return std::make_unique<MacRenderStrategy>();
    #else
        throw std::runtime_error("Unsupported platform");
    #endif
}

11.3 运行时平台切换

某些应用支持运行时切换渲染后端：

cpp复制class GraphicsContext {
    std::unique_ptr<RenderStrategy> renderer_;
public:
    void setRenderer(std::unique_ptr<RenderStrategy> renderer) {
        renderer_ = std::move(renderer);
    }
    
    void renderUI() {
        renderer_->drawWindow(0, 0, 800, 600);
        renderer_->drawButton(10, 10, 100, 50, "OK");
    }
};

12. 策略模式在游戏开发中的应用

游戏开发是策略模式的典型应用场景。以游戏AI为例：

12.1 AI行为策略

cpp复制class AIStrategy {
public:
    virtual ~AIStrategy() = default;
    virtual void update(NPC& npc, float deltaTime) = 0;
};

class AggressiveStrategy : public AIStrategy {
    void update(NPC& npc, float deltaTime) override {
        // 寻找最近玩家并攻击
    }
};

class DefensiveStrategy : public AIStrategy {
    void update(NPC& npc, float deltaTime) override {
        // 保持距离并寻找掩体
    }
};

12.2 动态策略切换

NPC可以根据游戏状态改变行为：

cpp复制class NPC {
    std::unique_ptr<AIStrategy> strategy_;
    float health_;
public:
    void update(float deltaTime) {
        // 血量低时切换为防御策略
        if(health_ < 30.0f && !dynamic_cast<DefensiveStrategy*>(strategy_.get())) {
            strategy_ = std::make_unique<DefensiveStrategy>();
        }
        
        strategy_->update(*this, deltaTime);
    }
};

12.3 策略与行为树的结合

现代游戏AI常结合策略模式和行为树：

cpp复制class BehaviorTreeStrategy : public AIStrategy {
    BehaviorTree tree_;
public:
    BehaviorTreeStrategy(const std::string& treeDefinition) {
        tree_.load(treeDefinition);
    }
    
    void update(NPC& npc, float deltaTime) override {
        tree_.run(npc, deltaTime);
    }
};

这种混合架构既保持了策略模式的灵活性，又获得了行为树的可视化编辑优势。