C++策略模式：从基础实现到现代优化技巧

1. 策略模式基础回顾：从经典实现到C++特性适配

在面向对象设计中，策略模式（Strategy Pattern）允许在运行时选择算法行为。传统实现通常涉及三个角色：抽象策略接口、具体策略类集合和持有策略引用的上下文类。C++作为多范式语言，其策略模式的实现呈现出独特的语言特性适配。

经典策略模式的UML结构通常表现为：

code复制Context → Strategy
          ↑
ConcreteStrategyA
ConcreteStrategyB

在C++中，这种基础实现需要特别注意资源管理问题。与Java等语言不同，C++没有自动垃圾回收机制，策略对象的生命周期管理成为关键考量。智能指针（如std::unique_ptr）的引入使实现更加安全：

cpp复制class SortingStrategy {
public:
    virtual ~SortingStrategy() = default;
    virtual void sort(std::vector<int>& data) const = 0;
};

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

class Context {
    std::unique_ptr<SortingStrategy> strategy_;
public:
    explicit Context(std::unique_ptr<SortingStrategy> strategy)
        : strategy_(std::move(strategy)) {}
    
    void executeStrategy(std::vector<int>& data) {
        strategy_->sort(data);
    }
};

注意：策略接口必须声明虚析构函数，否则通过基类指针删除派生类对象会导致资源泄漏。这是C++实现策略模式时最容易忽视的安全隐患。

2. 模板元编程策略：编译期多态的实现艺术

C++模板提供了另一种策略实现方式，通过在编译期确定具体策略，完全消除运行时开销。这种技术被广泛应用于标准库（如std::sort的比较策略）和高性能计算领域。

模板策略模式的典型实现：

cpp复制template <typename Strategy>
class Context {
    Strategy strategy_;
public:
    void execute(std::vector<int>& data) {
        strategy_.sort(data);
    }
};

struct BubbleSort {
    void sort(std::vector<int>& data) const {
        // 冒泡排序实现
    }
};

// 使用示例
Context<BubbleSort> context;
context.execute(data);

这种方式的优势在于：

• 零运行时开销：所有策略调用在编译期确定
• 更好的编译器优化：内联策略方法成为可能
• 更强的类型安全：策略接口通过模板参数静态检查

但需要注意模板策略的局限性：

1. 策略必须在编译期确定，无法运行时切换
2. 错误信息难以理解（典型的模板元编程问题）
3. 代码膨胀风险（每个策略类型生成独立代码)

3. 函数对象策略：STL风格的可调用对象实践

现代C++（C++11起）的函数对象特性为策略模式提供了更灵活的解决方案。通过std::function和lambda表达式，策略可以表示为任何可调用实体，极大扩展了策略模式的适用场景。

基于std::function的实现示例：

cpp复制class Context {
    std::function<void(std::vector<int>&)> strategy_;
public:
    void setStrategy(std::function<void(std::vector<int>&)> strategy) {
        strategy_ = strategy;
    }
    
    void execute(std::vector<int>& data) {
        if(strategy_) strategy_(data);
    }
};

// 使用示例
Context ctx;
ctx.setStrategy([](std::vector<int>& data) {
    // Lambda实现的排序策略
});
ctx.execute(data);

这种实现方式的独特价值在于：

• 策略可以是函数指针、成员函数指针、lambda表达式或函数对象
• 运行时策略切换成本极低
• 与STL算法风格高度一致
• 支持状态保持（有状态的函数对象）

实际工程中的典型应用场景：

• 回调机制（如事件处理系统）
• 算法参数化（如绘图库的渲染策略）
• 测试替身（如单元测试中的mock策略）

4. 策略组合模式：多维度策略的协同工作

复杂系统往往需要多个策略协同工作。通过策略的组合，可以构建更灵活的行为系统。C++的多继承和混入（mixin）特性为此提供了优雅的实现途径。

组合策略的两种典型实现方式：

4.1 策略栈模式

cpp复制class CompositeStrategy {
    std::vector<std::function<void(std::string&)>> strategies_;
public:
    void addStrategy(std::function<void(std::string&)> strat) {
        strategies_.push_back(strat);
    }
    
    void execute(std::string& data) {
        for(auto& strat : strategies_) {
            strat(data);
        }
    }
};

// 使用示例
CompositeStrategy pipeline;
pipeline.addStrategy([](std::string& s) { /* 策略A */ });
pipeline.addStrategy([](std::string& s) { /* 策略B */ });
pipeline.execute(data);

4.2 策略标记分发

cpp复制template <typename... Strategies>
class TaggedStrategy : private Strategies... {
public:
    template <typename T>
    void apply(T& data) {
        if constexpr(std::is_base_of_v<FilterTag, T>) {
            Strategies::filter(data)...;
        }
        else if constexpr(std::is_base_of_v<SortTag, T>) {
            Strategies::sort(data)...;
        }
    }
};

// 使用示例
struct AlphaFilter { void filter(Data&) const; };
struct BetaSort { void sort(Data&) const; };
TaggedStrategy<AlphaFilter, BetaSort> strategy;

组合策略模式在以下场景表现优异：

• 数据处理流水线（如编译器优化pass）
• 多阶段验证系统（如表单验证）
• 可插拔的中间件架构

5. 类型擦除策略：运行时多态的通用解决方案

类型擦除技术（如std::any、std::variant）为策略模式提供了另一种实现维度，允许在保持类型安全的同时处理未知策略类型。这种技术在框架开发和库设计中尤为重要。

基于std::variant的实现示例：

cpp复制class Context {
    using Strategy = std::variant<LinearSearch, BinarySearch, HashSearch>;
    Strategy strategy_;
public:
    template <typename S>
    void setStrategy(S&& s) {
        strategy_ = std::forward<S>(s);
    }
    
    void execute(const Data& query) {
        std::visit([&](auto&& s) {
            s.search(query);
        }, strategy_);
    }
};

类型擦除策略的关键优势：

• 避免动态内存分配（与继承方案相比）
• 支持值语义策略对象
• 编译时检查策略类型有效性
• 与C++17的std::visit天然契合

典型应用案例：

• 状态机实现
• 插件系统
• 多算法调度器

6. 策略模式性能优化：缓存与分支预测

在高性能场景下，策略调用的开销可能成为瓶颈。C++提供了多种优化策略执行的技巧：

6.1 策略缓存优化

cpp复制class OptimizedContext {
    Strategy* current_;
    StrategyCache cache_;
    
    void updateStrategy(int condition) {
        current_ = cache_.get(condition); // 避免重复创建
    }
public:
    void execute() {
        current_->operation();
    }
};

6.2 分支预测友好设计

cpp复制void execute() {
    if(__builtin_expect(condition, true)) {
        fastPathStrategy_();
    } else {
        slowPathStrategy_();
    }
}

6.3 策略局部性优化

cpp复制class BatchProcessor {
    alignas(64) Strategy strategies_[8]; // 缓存行对齐
    // ...
};

优化效果对比（测试数据参考）：

7. 现代C++策略模式的最佳实践

结合C++17/20的新特性，策略模式实现可以更加优雅和安全：

7.1 使用concept约束策略类型

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

template <SortStrategy S>
class SortedContainer {
    S strategy_;
    // ...
};

7.2 策略对象的线程安全保证

cpp复制class ThreadSafeContext {
    mutable std::shared_mutex mtx_;
    std::shared_ptr<Strategy> strategy_;
public:
    void updateStrategy(std::shared_ptr<Strategy> newStrat) {
        std::unique_lock lock(mtx_);
        strategy_.swap(newStrat);
    }
    
    void execute() const {
        std::shared_lock lock(mtx_);
        strategy_->operation();
    }
};

7.3 策略的constexpr实现

cpp复制struct ConstexprStrategy {
    constexpr int operator()(int x) const {
        return x * 2; // 编译期可计算
    }
};

template <typename S>
constexpr auto process(S strategy, int x) {
    return strategy(x);
}

工程实践中的经验法则：

1. 性能敏感场景优先考虑模板策略
2. 需要运行时动态切换时选择std::function方案
3. 策略接口复杂时保持经典面向对象实现
4. 多策略协作考虑组合模式
5. 跨模块边界使用类型擦除技术