C++中如何实现策略模式？函数对象与lambda表达式详解

策略模式的核心思想是定义一系列算法，把每一个算法封装起来，并且使它们可以相互替换。在C++中，实现策略模式的方式远比其他语言丰富：既可以用传统的虚函数继承，也可以借助函数对象、lambda表达式甚至模板参数来完成。不同的实现方式在性能、灵活性和代码复杂度上各有取舍，本文将系统地讲解这几种方案，并给出实际开发中的选型建议。

传统面向对象方式：虚函数实现策略模式

最经典的实现方式是定义一个抽象策略基类，声明纯虚函数作为算法接口，然后为每种具体策略派生一个子类。客户端持有一个指向基类的指针或引用，在运行时注入不同的策略对象。这种写法的好处是结构清晰，符合面向接口编程的原则，策略对象可以携带自己的成员变量和内部状态，特别适合算法本身比较复杂、需要维护状态的场景。

#include <iostream>
#include <vector>
#include <memory>

// 抽象策略接口
class SortStrategy {
public:
    virtual ~SortStrategy() = default;
    virtual void sort(std::vector<int>& data) = 0;
};

// 具体策略：升序排序
class AscendSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        std::sort(data.begin(), data.end());
    }
};

// 具体策略：降序排序
class DescendSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        std::sort(data.begin(), data.end(), std::greater<int>());
    }
};

// 上下文类
class Sorter {
public:
    explicit Sorter(std::shared_ptr<SortStrategy> s) : strategy_(std::move(s)) {}
    void setStrategy(std::shared_ptr<SortStrategy> s) { strategy_ = std::move(s); }
    void doSort(std::vector<int>& data) { strategy_->sort(data); }
private:
    std::shared_ptr<SortStrategy> strategy_;
};

int main() {
    std::vector<int> v{5, 2, 9, 1, 7};
    Sorter sorter(std::make_shared<AscendSort>());
    sorter.doSort(v);  // 升序
    sorter.setStrategy(std::make_shared<DescendSort>());
    sorter.doSort(v);  // 降序
    return 0;
}

这种方案的缺点也很明显：每增加一种策略就要新建一个类，代码量膨胀迅速。如果策略只是简单的比较逻辑，为一个lambda的逻辑去写一整个头文件就显得小题大做。此外，虚函数调用存在间接寻址开销，编译器难以内联，在性能敏感的热点路径上可能成为瓶颈。

现代C++方式：std::function与lambda表达式

C++11引入的lambda表达式和std::function让策略模式的实现发生了质变。lambda本身就是一种函数对象，编译器会为它生成一个匿名类，并重载operator()。我们可以直接把lambda赋值给std::function类型的成员变量，从而把策略定义压缩到一行代码。

#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>

class FlexibleSorter {
public:
    using Compare = std::function<bool(int, int)>;
    explicit FlexibleSorter(Compare cmp) : cmp_(std::move(cmp)) {}
    void doSort(std::vector<int>& data) {
        std::sort(data.begin(), data.end(), cmp_);
    }
private:
    Compare cmp_;
};

int main() {
    // 用lambda定义升序策略
    FlexibleSorter asc([](int a, int b) { return a < b; });
    std::vector<int> v{5, 2, 9, 1, 7};
    asc.doSort(v);

    // 用lambda定义降序策略，切换策略只需换一个lambda
    FlexibleSorter desc([](int a, int b) { return a > b; });
    desc.doSort(v);
    return 0;
}

这种写法的优势在于策略的即席定义能力：lambda可以出现在调用现场，可以捕获上下文变量，代码意图一目了然。相比虚函数方案，它省去了类定义、继承体系和对象构造的开销。std::function本身是一个类型擦除容器，能存放任何签名匹配的可调用对象，包括普通函数、函数对象、lambda甚至bind的结果。

需要注意的是，std::function并不是免费的午餐。类型擦除意味着内部可能发生堆分配（当可调用对象超过小缓冲区大小时），调用时也存在一层间接跳转。如果性能要求极高，应该考虑下面的模板方案。另外，lambda捕获列表中如果按引用捕获局部变量，必须确保lambda的生命周期不超过被捕获变量的生命周期，否则会产生悬空引用。

零开销方式：模板参数传递策略

如果策略可以在编译期确定，模板参数是性能最优的选择。把策略类型作为模板参数传入，编译器能完整看到具体类型的operator()实现，从而进行内联优化，实现零开销抽象。标准库中的std::sort、std::map等容器都是采用这种设计，这也是C++标准库把比较器设计成模板参数而非构造函数参数的原因。

#include <iostream>
#include <vector>
#include <algorithm>

template <typename Compare>
class FastSorter {
public:
    void doSort(std::vector<int>& data, Compare cmp) {
        std::sort(data.begin(), data.end(), cmp);  // cmp可被完全内联
    }
};

int main() {
    std::vector<int> v{5, 2, 9, 1, 7};
    auto ascCmp = [](int a, int b) { return a < b; };
    FastSorter<decltype(ascCmp)> sorter;
    sorter.doSort(v, ascCmp);
    return 0;
}

模板方案的代价是灵活性降低：策略类型在编译期就固定了，无法在运行时动态切换，而且不同的策略类型会实例化出不同的类，可能导致代码体积膨胀。对于编译期就能确定的逻辑，比如某种容器始终使用固定哈希函数，模板方案是最佳选择；对于需要运行时切换的场景，比如根据用户配置选择不同的压缩算法，则应使用std::function或虚函数。

三种方案的对比与选型建议

下表从多个维度对比三种实现方式，方便大家在实际项目中做选择：

选型时可以遵循这样的思路：简单的一次性逻辑优先用lambda配合std::function，代码最简洁直观；策略复杂、有完整状态和生命周期管理需求时用虚函数继承，还能配合工厂模式创建策略对象；处于性能热点且编译期可确定时用模板参数。三种方式并不互斥，一个成熟的项目往往同时使用它们：底层算法用模板保证性能，上层配置用std::function提供运行时灵活性，接口层用抽象基类对接外部扩展。

最后补充一个实践建议：使用std::function作为参数时，如果只是同步调用一次，尽量直接用模板参数接收可调用对象，可以避免不必要的std::function构造开销；只有在需要存储策略、延迟调用时才使用std::function。理解函数对象、lambda和std::function三者的关系，是掌握现代C++设计模式的关键一步。

策略模式函数对象lambda表达式修改时间：2026-09-02 01:30:31