C++策略模式：从基础到高级应用全解析

1. 策略模式的核心概念回顾

在深入探讨策略模式的进阶应用之前，我们需要先明确其基本定义和典型实现。策略模式（Strategy Pattern）是一种行为设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。这种模式让算法的变化独立于使用算法的客户端。

在C++中，策略模式的经典实现通常包含三个关键组成部分：

• Context（上下文）：维护一个对Strategy对象的引用，通过接口与策略对象交互
• Strategy（策略接口）：定义所有支持的算法的公共接口
• ConcreteStrategy（具体策略）：实现Strategy接口的具体算法类

以下是一个简单的支付策略示例代码框架：

cpp复制// 策略接口
class PaymentStrategy {
public:
    virtual void pay(int amount) = 0;
    virtual ~PaymentStrategy() = default;
};

// 具体策略：信用卡支付
class CreditCardPayment : public PaymentStrategy {
public:
    void pay(int amount) override {
        std::cout << "Paying " << amount << " via Credit Card" << std::endl;
    }
};

// 具体策略：支付宝支付
class AlipayPayment : public PaymentStrategy {
public:
    void pay(int amount) override {
        std::cout << "Paying " << amount << " via Alipay" << std::endl;
    }
};

// 上下文
class PaymentContext {
private:
    std::unique_ptr<PaymentStrategy> strategy;
public:
    explicit PaymentContext(std::unique_ptr<PaymentStrategy> strategy)
        : strategy(std::move(strategy)) {}
    
    void executePayment(int amount) {
        strategy->pay(amount);
    }
};

这种基础实现虽然简单，但在实际工程中会遇到各种复杂情况。比如当策略需要访问上下文状态时，或者当策略的创建过程比较复杂时，简单的策略模式就需要进行扩展和优化。

2. 策略模式的高级实现技巧

2.1 使用模板实现编译时策略选择

对于性能敏感的场景，我们可以利用C++模板在编译期确定策略，避免运行时多态的开销。这种技术被称为"策略作为模板参数"（Policy-based Design）。

cpp复制template <typename SortingStrategy>
class Sorter {
public:
    void sort(std::vector<int>& data) {
        SortingStrategy::execute(data);
    }
};

// 具体策略：快速排序
struct QuickSort {
    static void execute(std::vector<int>& data) {
        std::cout << "Sorting with QuickSort" << std::endl;
        // 实际排序实现...
    }
};

// 具体策略：归并排序
struct MergeSort {
    static void execute(std::vector<int>& data) {
        std::cout << "Sorting with MergeSort" << std::endl;
        // 实际排序实现...
    }
};

// 使用示例
Sorter<QuickSort> quickSorter;
quickSorter.sort(data);

这种方式的优势在于：

• 零运行时开销：所有策略调用在编译期确定
• 更强的类型安全性：策略接口通过模板实例化检查
• 更好的编译器优化：策略代码可以被内联

注意：这种技术适用于策略在程序生命周期内不变的情况。如果需要运行时动态切换策略，仍需使用传统的虚函数实现。

2.2 策略与状态模式的结合应用

在实际项目中，策略模式常与状态模式结合使用，形成更灵活的行为管理系统。两者的关键区别在于：

• 策略模式：算法或行为的选择
• 状态模式：对象内部状态的变化

一个游戏AI的示例：

cpp复制// 状态接口
class AIState {
public:
    virtual void update(AIController* controller) = 0;
    virtual ~AIState() = default;
};

// 策略接口
class MovementStrategy {
public:
    virtual void move(AICharacter* character) = 0;
    virtual ~MovementStrategy() = default;
};

// 具体状态：巡逻状态
class PatrolState : public AIState {
private:
    std::unique_ptr<MovementStrategy> movementStrategy;
public:
    explicit PatrolState(std::unique_ptr<MovementStrategy> strategy)
        : movementStrategy(std::move(strategy)) {}
    
    void update(AIController* controller) override {
        // 巡逻状态特有的逻辑
        movementStrategy->move(controller->getCharacter());
        
        // 可能的状态转换
        if (controller->detectEnemy()) {
            controller->setState(std::make_unique<CombatState>());
        }
    }
};

// 具体策略：路径点移动
class WaypointMovement : public MovementStrategy {
public:
    void move(AICharacter* character) override {
        // 实现路径点移动逻辑
    }
};

这种组合模式特别适合游戏开发、工作流引擎等需要同时管理状态和行为策略的场景。

3. 现代C++特性在策略模式中的应用

3.1 使用std::function实现灵活的策略绑定

C++11引入的std::function和lambda表达式为策略模式提供了更灵活的替代方案。我们可以将策略定义为可调用对象，而不必拘泥于传统的继承体系。

cpp复制class TextProcessor {
private:
    std::function<std::string(const std::string&)> processingStrategy;
public:
    void setProcessingStrategy(std::function<std::string(const std::string&)> strategy) {
        processingStrategy = std::move(strategy);
    }
    
    std::string process(const std::string& text) {
        return processingStrategy ? processingStrategy(text) : text;
    }
};

// 使用示例
TextProcessor processor;

// 使用lambda表达式作为策略
processor.setProcessingStrategy([](const std::string& text) {
    std::string result = text;
    std::transform(result.begin(), result.end(), result.begin(), ::toupper);
    return result;
});

// 使用普通函数作为策略
std::string reverseText(const std::string& text) {
    return std::string(text.rbegin(), text.rend());
}
processor.setProcessingStrategy(reverseText);

这种方式的优势在于：

• 策略可以是任何可调用对象（函数、lambda、函数对象等）
• 不需要创建策略类层次结构
• 更简洁的代码，特别适合一次性使用的简单策略

3.2 使用变参模板实现策略组合

C++11的变参模板允许我们创建可以接受任意数量策略的类，这在实现策略组合或装饰器模式时特别有用。

cpp复制template <typename... Strategies>
class CompositeStrategy {
private:
    std::tuple<Strategies...> strategies;
public:
    void executeAll() {
        // 使用折叠表达式(C++17)依次执行所有策略
        (std::get<Strategies>(strategies).execute(), ...);
    }
};

// 具体策略A
struct LoggingStrategy {
    void execute() { std::cout << "Logging..." << std::endl; }
};

// 具体策略B
struct ValidationStrategy {
    void execute() { std::cout << "Validating..." << std::endl; }
};

// 使用示例
CompositeStrategy<LoggingStrategy, ValidationStrategy> processor;
processor.executeAll();

这种技术可以创建非常灵活的策略组合系统，每个策略可以专注于单一职责，然后通过组合形成复杂行为。

4. 策略模式在大型项目中的实践

4.1 策略工厂与依赖注入

在大型项目中，直接实例化具体策略类会导致代码耦合度高。我们可以使用工厂模式和依赖注入来解耦策略的创建和使用。

cpp复制// 策略工厂接口
class StrategyFactory {
public:
    virtual std::unique_ptr<PaymentStrategy> createPaymentStrategy() = 0;
    virtual ~StrategyFactory() = default;
};

// 具体工厂
class AlipayStrategyFactory : public StrategyFactory {
public:
    std::unique_ptr<PaymentStrategy> createPaymentStrategy() override {
        return std::make_unique<AlipayPayment>();
    }
};

// 使用依赖注入的上下文
class PaymentProcessor {
private:
    std::shared_ptr<StrategyFactory> factory;
public:
    explicit PaymentProcessor(std::shared_ptr<StrategyFactory> factory)
        : factory(std::move(factory)) {}
    
    void processPayment(int amount) {
        auto strategy = factory->createPaymentStrategy();
        strategy->pay(amount);
    }
};

这种架构的优势：

• 策略创建逻辑集中管理
• 便于单元测试（可以注入mock工厂）
• 运行时动态切换策略创建方式

4.2 策略模式与插件架构

策略模式常被用于实现插件系统，允许第三方开发者扩展应用程序功能而不必修改核心代码。

cpp复制// 核心系统定义的策略接口
class ExportStrategy {
public:
    virtual void exportData(const Data& data) = 0;
    virtual ~ExportStrategy() = default;
};

// 插件管理器
class PluginManager {
private:
    std::vector<std::shared_ptr<ExportStrategy>> plugins;
public:
    void loadPlugin(const std::string& path) {
        // 动态加载DLL/so并获取插件实例
        // 实际项目中会使用dlopen/LoadLibrary等API
        auto plugin = std::make_shared<PDFExportPlugin>();
        plugins.push_back(plugin);
    }
    
    void exportAll(const Data& data) {
        for (auto& plugin : plugins) {
            plugin->exportData(data);
        }
    }
};

// 第三方插件实现
class PDFExportPlugin : public ExportStrategy {
public:
    void exportData(const Data& data) override {
        // 实现PDF导出逻辑
    }
};

在实际项目中，这种架构常用于：

• 文件格式导入/导出系统
• 数据分析处理管道
• 图形渲染后端

4.3 策略模式与并发编程

在多线程环境中使用策略模式需要注意线程安全问题。我们可以使用多种技术来保证策略的安全使用：

1. 不可变策略：设计策略类为无状态的，所有必要数据通过参数传递
2. 线程局部策略：每个线程有自己的策略实例
3. 保护策略：使用互斥锁保护策略状态

cpp复制// 线程安全的策略上下文
class ThreadSafeContext {
private:
    std::mutex mtx;
    std::unique_ptr<Strategy> strategy;
public:
    void setStrategy(std::unique_ptr<Strategy> newStrategy) {
        std::lock_guard<std::mutex> lock(mtx);
        strategy = std::move(newStrategy);
    }
    
    void execute() {
        std::lock_guard<std::mutex> lock(mtx);
        if (strategy) {
            strategy->execute();
        }
    }
};

对于高性能场景，可以考虑使用无锁数据结构或原子操作来优化策略的切换和执行。

5. 策略模式的性能考量与优化

5.1 虚函数调用开销分析

传统策略模式使用虚函数实现多态，这带来了运行时开销。虚函数调用的开销主要来自：

1. 间接跳转（通过虚函数表）
2. 编译器优化受限（难以内联）
3. 缓存不友好（虚表指针占用空间）

在性能敏感的场景中，可以考虑以下优化技术：

1. 策略内联缓存：缓存常用策略的直接调用地址
2. 策略预测：基于历史数据预测可能使用的策略
3. 批量策略执行：一次处理多个数据，分摊调用开销

5.2 基于标签分派的策略选择

C++17的if constexpr和标签分派可以创建高效的策略选择机制：

cpp复制struct FastStrategyTag {};
struct SafeStrategyTag {};

template <typename Tag>
class Processor {
public:
    void process() {
        if constexpr (std::is_same_v<Tag, FastStrategyTag>) {
            // 快速策略实现
        } else if constexpr (std::is_same_v<Tag, SafeStrategyTag>) {
            // 安全策略实现
        }
    }
};

// 使用示例
Processor<FastStrategyTag> fastProcessor;
fastProcessor.process();

这种技术在编译期就确定了使用的策略，完全消除了运行时开销。

5.3 策略对象的内存优化

频繁创建和销毁策略对象可能导致内存分配成为瓶颈。可以考虑：

1. 策略对象池：预分配策略实例，重复使用
2. 小对象优化：将策略存储在上下文内部的缓冲区中，避免堆分配
3. 策略共享：无状态策略可以共享同一实例

cpp复制// 小对象优化示例
class OptimizedContext {
private:
    std::aligned_storage_t<64> storage; // 足够存储大多数策略对象
    Strategy* strategy = nullptr;
public:
    template <typename S, typename... Args>
    void setStrategy(Args&&... args) {
        static_assert(sizeof(S) <= sizeof(storage), "Strategy too large");
        strategy = new (&storage) S(std::forward<Args>(args)...);
    }
    
    ~OptimizedContext() {
        if (strategy) {
            strategy->~Strategy();
        }
    }
};

这种技术特别适合嵌入式系统或高频交易等内存受限或性能关键的应用场景。

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

6.1 策略模式的单元测试策略

良好的策略模式实现应该便于单元测试。以下是几种测试策略：

1. 模拟策略：创建用于测试的模拟策略
2. 验证策略调用：确保上下文正确调用了策略
3. 边界条件测试：测试策略在极端输入下的行为

cpp复制// 模拟策略示例
class MockStrategy : public Strategy {
public:
    MOCK_METHOD(void, execute, (), (override));
};

TEST(ContextTest, ExecutesStrategy) {
    MockStrategy mock;
    EXPECT_CALL(mock, execute()).Times(1);
    
    Context context(&mock);
    context.run();
}

6.2 策略模式的调试技巧

调试策略模式时可能会遇到以下典型问题：

1. 策略未正确设置：上下文使用了空或错误的策略
2. 策略状态不一致：多线程环境下策略状态被意外修改
3. 策略性能问题：某些策略执行时间过长

调试建议：

• 在策略调用前后添加日志
• 使用断言检查策略前置条件
• 对策略执行时间进行监控

cpp复制class LoggingStrategyProxy : public Strategy {
private:
    std::shared_ptr<Strategy> wrapped;
public:
    explicit LoggingStrategyProxy(std::shared_ptr<Strategy> strategy)
        : wrapped(std::move(strategy)) {}
    
    void execute() override {
        auto start = std::chrono::high_resolution_clock::now();
        wrapped->execute();
        auto end = std::chrono::high_resolution_clock::now();
        std::cout << "Strategy executed in "
                  << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count()
                  << "μs" << std::endl;
    }
};

这种代理模式可以在不修改原有策略代码的情况下添加调试功能。

7. 策略模式的反模式与最佳实践

7.1 策略模式常见误用

1. 过度设计：对简单、不可能变化的行为使用策略模式
2. 策略膨胀：创建过多细粒度的策略类
3. 上下文耦合：策略需要知道太多上下文细节
4. 状态与策略混淆：错误地用策略模式实现状态相关的行为

7.2 策略模式最佳实践

1. 策略接口精简：策略接口应该尽可能小而专注
2. 无状态策略：优先设计无状态的策略，必要时通过参数传递数据
3. 策略组合：通过组合简单策略构建复杂行为
4. 合理选择实现方式：根据需求选择运行时多态、模板策略或std::function
5. 文档化策略契约：明确记录每个策略的前置条件、后置条件和副作用

cpp复制/**
 * @brief 排序策略接口
 * 
 * 契约：
 * - 前置条件：data不为空
 * - 后置条件：data中的元素按非降序排列
 * - 副作用：可能修改data内容
 */
class SortStrategy {
public:
    virtual void sort(std::vector<int>& data) = 0;
    virtual ~SortStrategy() = default;
};

良好的文档可以帮助团队成员正确实现和使用策略。

8. 策略模式与其他设计模式的协同

8.1 策略与工厂模式结合

如前所述，策略模式常与工厂模式一起使用，以封装策略的创建逻辑。更高级的用法可以结合抽象工厂创建相关策略族。

cpp复制// 抽象策略工厂
class GUIRenderingFactory {
public:
    virtual std::unique_ptr<RenderStrategy> createRenderStrategy() = 0;
    virtual std::unique_ptr<LayoutStrategy> createLayoutStrategy() = 0;
    virtual ~GUIRenderingFactory() = default;
};

// 具体工厂：Windows风格
class WindowsFactory : public GUIRenderingFactory {
public:
    std::unique_ptr<RenderStrategy> createRenderStrategy() override {
        return std::make_unique<WindowsRenderStrategy>();
    }
    
    std::unique_ptr<LayoutStrategy> createLayoutStrategy() override {
        return std::make_unique<WindowsLayoutStrategy>();
    }
};

这种模式确保了相关策略之间的一致性，比如所有创建的策略都遵循相同的视觉风格。

8.2 策略与装饰器模式结合

装饰器模式可以动态地为策略添加附加功能，而不需要修改策略本身。

cpp复制// 装饰器基类
class StrategyDecorator : public Strategy {
protected:
    std::shared_ptr<Strategy> wrapped;
public:
    explicit StrategyDecorator(std::shared_ptr<Strategy> strategy)
        : wrapped(std::move(strategy)) {}
    
    void execute() override {
        wrapped->execute();
    }
};

// 具体装饰器：添加日志功能
class LoggingDecorator : public StrategyDecorator {
public:
    using StrategyDecorator::StrategyDecorator;
    
    void execute() override {
        std::cout << "Before strategy execution" << std::endl;
        StrategyDecorator::execute();
        std::cout << "After strategy execution" << std::endl;
    }
};

这种技术特别适合横切关注点（如日志、性能监控、安全检查等）的实现。

8.3 策略与观察者模式结合

当策略执行需要通知其他对象时，可以结合观察者模式实现松耦合的通知机制。

cpp复制class ObservableStrategy : public Strategy {
private:
    std::vector<std::function<void()>> observers;
public:
    void addObserver(std::function<void()> observer) {
        observers.push_back(std::move(observer));
    }
    
    void execute() override {
        // 策略具体逻辑...
        
        // 通知观察者
        for (const auto& observer : observers) {
            observer();
        }
    }
};

这种模式在实现GUI事件处理、异步操作回调等场景时非常有用。

9. C++20/23新特性对策略模式的影响

9.1 概念(Concepts)约束策略类型

C++20的概念(Concepts)可以更好地约束模板策略的接口要求，提供更清晰的编译期错误信息。

cpp复制template <typename S>
concept SortingStrategy = requires(S s, std::vector<int>& v) {
    { s.sort(v) } -> std::same_as<void>;
};

template <SortingStrategy S>
class SortableContainer {
private:
    S sorter;
public:
    void sort(std::vector<int>& data) {
        sorter.sort(data);
    }
};

这种方式的优势在于：

• 更清晰的接口要求
• 更好的错误信息
• 编译期接口检查

9.2 协程(Coroutines)与异步策略

C++20的协程为异步策略的实现提供了新的可能性。我们可以创建基于协程的异步策略接口。

cpp复制class AsyncStrategy {
public:
    struct promise_type {
        AsyncStrategy get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
    
    virtual std::future<void> executeAsync() = 0;
    virtual ~AsyncStrategy() = default;
};

class NetworkFetchStrategy : public AsyncStrategy {
public:
    std::future<void> executeAsync() override {
        co_await std::async([]{
            // 异步网络请求实现
        });
    }
};

这种模式非常适合I/O密集型操作的策略实现。

9.3 模块(Modules)与策略编译隔离

C++20的模块系统可以更好地封装策略实现细节，减少编译依赖。

cpp复制// Strategy.ixx
export module Strategy;

export {
    class Strategy {
    public:
        virtual void execute() = 0;
        virtual ~Strategy() = default;
    };
    
    class Context {
    private:
        std::unique_ptr<Strategy> strategy;
    public:
        void setStrategy(std::unique_ptr<Strategy> s);
        void execute();
    };
}

// ConcreteStrategy.ixx
export module ConcreteStrategy;

import Strategy;

export namespace Strategies {
    class ConcreteA : public Strategy {
    public:
        void execute() override;
    };
}

模块化带来的好处：

• 更清晰的接口/实现分离
• 更快的编译速度
• 更好的封装性

10. 策略模式在实际项目中的案例研究

10.1 游戏开发中的AI行为策略

在游戏开发中，策略模式广泛应用于AI行为管理。不同的NPC可以根据情境采用不同的行为策略。

cpp复制// AI行为策略接口
class AIBehavior {
public:
    virtual void update(NPC& npc, float deltaTime) = 0;
    virtual ~AIBehavior() = default;
};

// 具体策略：巡逻行为
class PatrolBehavior : public AIBehavior {
private:
    std::vector<Waypoint> waypoints;
    size_t currentWaypoint = 0;
public:
    void update(NPC& npc, float deltaTime) override {
        // 实现巡逻逻辑
        if (reachedWaypoint(npc.position)) {
            currentWaypoint = (currentWaypoint + 1) % waypoints.size();
        }
        moveToward(npc, waypoints[currentWaypoint], deltaTime);
    }
};

// 具体策略：追击行为
class ChaseBehavior : public AIBehavior {
public:
    void update(NPC& npc, float deltaTime) override {
        auto target = npc.getNearestEnemy();
        if (target) {
            moveToward(npc, target->position, deltaTime);
        }
    }
};

// AI控制器
class AIController {
private:
    std::unique_ptr<AIBehavior> currentBehavior;
public:
    void setBehavior(std::unique_ptr<AIBehavior> behavior) {
        currentBehavior = std::move(behavior);
    }
    
    void update(NPC& npc, float deltaTime) {
        if (currentBehavior) {
            currentBehavior->update(npc, deltaTime);
        }
    }
};

这种架构允许：

• 快速添加新的AI行为
• 动态调整NPC行为
• 复用行为逻辑

10.2 金融系统中的风险计算策略

在金融系统中，不同的产品可能需要不同的风险计算策略。

cpp复制// 风险计算策略
class RiskCalculator {
public:
    virtual double calculateRisk(const Portfolio& portfolio) = 0;
    virtual ~RiskCalculator() = default;
};

// 具体策略：VaR计算
class VarCalculator : public RiskCalculator {
public:
    double calculateRisk(const Portfolio& portfolio) override {
        // 实现Value at Risk计算
    }
};

// 具体策略：ES计算
class ExpectedShortfallCalculator : public RiskCalculator {
public:
    double calculateRisk(const Portfolio& portfolio) override {
        // 实现Expected Shortfall计算
    }
};

// 风险管理系统
class RiskManager {
private:
    std::map<ProductType, std::unique_ptr<RiskCalculator>> calculators;
public:
    void setCalculator(ProductType type, std::unique_ptr<RiskCalculator> calc) {
        calculators[type] = std::move(calc);
    }
    
    double evaluateRisk(const Product& product) {
        auto it = calculators.find(product.getType());
        if (it != calculators.end()) {
            return it->second->calculateRisk(product.getPortfolio());
        }
        throw std::runtime_error("No calculator for product type");
    }
};

这种设计允许：

• 不同产品类型使用不同的风险模型
• 动态更新风险计算算法
• 便于合规审计

10.3 编译器优化策略选择

现代编译器经常使用策略模式来选择不同的优化策略。

cpp复制// 优化策略接口
class OptimizationStrategy {
public:
    virtual void optimize(IRModule& module) = 0;
    virtual ~OptimizationStrategy() = default;
};

// 具体策略：常量传播
class ConstantPropagation : public OptimizationStrategy {
public:
    void optimize(IRModule& module) override {
        // 实现常量传播优化
    }
};

// 具体策略：死代码消除
class DeadCodeElimination : public OptimizationStrategy {
public:
    void optimize(IRModule& module) override {
        // 实现死代码消除
    }
};

// 优化管道
class OptimizationPipeline {
private:
    std::vector<std::unique_ptr<OptimizationStrategy>> passes;
public:
    void addPass(std::unique_ptr<OptimizationStrategy> pass) {
        passes.push_back(std::move(pass));
    }
    
    void run(IRModule& module) {
        for (auto& pass : passes) {
            pass->optimize(module);
        }
    }
};

这种架构的优势：

• 灵活组合优化过程
• 易于添加新优化
• 支持优化级别调整

11. 策略模式的扩展与变体

11.1 元策略模式

元策略模式是指策略本身也使用策略模式来选择执行方式。这种模式可以创建非常灵活的行为系统。

cpp复制// 基础策略接口
class ExecutionStrategy {
public:
    virtual void execute() = 0;
    virtual ~ExecutionStrategy() = default;
};

// 元策略接口
class MetaStrategy {
public:
    virtual std::unique_ptr<ExecutionStrategy> selectStrategy() = 0;
    virtual ~MetaStrategy() = default;
};

// 基于规则的元策略
class RuleBasedMetaStrategy : public MetaStrategy {
public:
    std::unique_ptr<ExecutionStrategy> selectStrategy() override {
        if (shouldUseFastPath()) {
            return std::make_unique<FastExecutionStrategy>();
        } else {
            return std::make_unique<SafeExecutionStrategy>();
        }
    }
};

// 上下文使用元策略
class Context {
private:
    std::unique_ptr<MetaStrategy> metaStrategy;
public:
    void execute() {
        auto strategy = metaStrategy->selectStrategy();
        strategy->execute();
    }
};

这种模式在自适应系统、智能代理等场景中非常有用。

11.2 策略链模式

策略链模式将多个策略按顺序执行，每个策略可以决定是否中断链或继续执行。

cpp复制class ChainableStrategy {
public:
    virtual bool execute(Context& context) = 0;
    virtual ~ChainableStrategy() = default;
};

class StrategyChain {
private:
    std::vector<std::unique_ptr<ChainableStrategy>> strategies;
public:
    void addStrategy(std::unique_ptr<ChainableStrategy> strategy) {
        strategies.push_back(std::move(strategy));
    }
    
    void execute(Context& context) {
        for (auto& strategy : strategies) {
            if (!strategy->execute(context)) {
                break; // 策略决定中断执行链
            }
        }
    }
};

这种模式常见于：

• 请求处理管道
• 事件过滤系统
• 验证流程

11.3 可组合策略模式

可组合策略允许策略之间相互组合形成更复杂的行为。

cpp复制class CompositeStrategy : public Strategy {
private:
    std::vector<std::shared_ptr<Strategy>> components;
public:
    void addComponent(std::shared_ptr<Strategy> strategy) {
        components.push_back(std::move(strategy));
    }
    
    void execute() override {
        for (auto& strategy : components) {
            strategy->execute();
        }
    }
};

这种模式的优势在于：

• 动态构建复杂行为
• 策略复用
• 运行时调整行为组合

12. 策略模式的未来发展趋势

12.1 机器学习驱动的策略选择

随着机器学习技术的发展，策略选择可以基于预测模型而非硬编码规则。

cpp复制class MLStrategySelector {
private:
    MLModel predictionModel;
public:
    std::unique_ptr<Strategy> selectOptimalStrategy(const ContextData& data) {
        auto prediction = predictionModel.predict(data);
        switch (prediction) {
            case Prediction::FastPath: return std::make_unique<FastStrategy>();
            case Prediction::SafePath: return std::make_unique<SafeStrategy>();
            default: return std::make_unique<DefaultStrategy>();
        }
    }
};

这种方法的优势在于可以基于实际运行数据不断优化策略选择。

12.2 自适应策略调整

未来的策略系统可能会实时监控自身性能并自动调整策略参数。

cpp复制class AdaptiveStrategy : public Strategy {
private:
    PerformanceMonitor monitor;
    StrategyParameters params;
public:
    void execute() override {
        auto start = monitor.start();
        
        // 使用当前参数执行策略
        executeWithParams(params);
        
        auto metrics = monitor.end(start);
        adjustParametersBasedOnMetrics(metrics);
    }
};

这种自适应策略特别适合变化环境中的应用场景。

12.3 分布式策略协同

在分布式系统中，策略可能需要跨节点协同工作。

cpp复制class DistributedStrategy : public Strategy {
private:
    std::vector<StrategyNode> nodes;
public:
    void execute() override {
        // 协调各节点策略执行
        auto consensus = reachConsensusOnApproach();
        
        // 并行执行策略
        std::vector<std::future<void>> futures;
        for (auto& node : nodes) {
            futures.push_back(std::async([&]{
                node.executePart(consensus);
            }));
        }
        
        // 等待完成
        for (auto& f : futures) f.wait();
        
        // 合并结果
        mergeResults();
    }
};

这种模式在边缘计算、分布式AI等场景中有广泛应用前景。