将C++ Lambda传入非模板函数的性能损耗及更优实现方案

1. 用std::function传Lambda给非模板sorter，处理大vector会有性能损耗吗？ #

肯定会，而且在你说的N*GB级超大vector场景下，这个损耗会特别明显。原因很简单：

• std::function靠类型擦除工作，它把Lambda的具体类型藏起来，每次调用比较逻辑都得通过内部的虚表或者函数指针间接跳转，编译器没法把这段逻辑内联到排序循环里。
• 而std::sort本身是模板函数，如果直接传Lambda，编译器能直接解析比较逻辑，把它内联到排序过程中，完全消除函数调用的开销。排序的比较次数是O(n log n)级别的，数据量越大，这部分额外开销累积得越多，性能差距会拉得很开。

哪怕std::function用了小对象优化（不用堆分配存Lambda），间接调用的开销还是没办法消除，这是类型擦除的固有代价。

2. 要保持sorter是非模板函数，有什么更优的实现方式？ #

如果必须死守非模板的要求，这里有几个可行的优化方向：

方案一：用自定义仿函数类代替Lambda #

把需要捕获的变量封装到一个自定义的可调用类里，再传给std::function。虽然还是有类型擦除的开销，但能避免Lambda转std::function时的一些小额外开销（实际差距不大，但聊胜于无），代码示例：

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

using namespace std;

void sorter(std::vector<int>& v, std::function<bool(int a, int b)> f){
    std::sort(v.begin(), v.end(), f);
}

// 自定义仿函数，把要捕获的c作为成员引用
struct Comparator {
    int& c;
    explicit Comparator(int& c_ref) : c(c_ref) {}
    bool operator()(int a, int b) const {
        return a + b < c;
    }
};

int main()
{
    std::vector<int> v = {5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
    for (auto val : v)
        cout << val << " ";
    cout << endl;

    int c = 4;
    sorter(v, Comparator(c));

    for (auto val : v)
        cout << val << " ";
    cout << endl;

    return 0;
}

方案二：用C++20的std::move_only_function（如果能升级编译器） #

std::move_only_function是std::function的轻量化替代，它不支持拷贝只允许移动，内部实现更高效，能减少不必要的拷贝开销，尤其适合传递带捕获的Lambda。修改后的代码大概是这样：

#include <iostream>
#include <functional> // 包含std::move_only_function
#include <algorithm>
#include <vector>

using namespace std;

void sorter(std::vector<int>& v, std::move_only_function<bool(int, int)> f){
    std::sort(v.begin(), v.end(), std::move(f));
}

int main()
{
    std::vector<int> v = {5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
    for (auto val : v)
        cout << val << " ";
    cout << endl;

    int c = 4;
    auto f = [&c](int a, int b){ return a+b < c; };
    sorter(v, std::move(f));

    for (auto val : v)
        cout << val << " ";
    cout << endl;

    return 0;
}

方案三：折中方案——非模板入口+内部模板实现 #

如果可以接受对外暴露一个非模板的“门面”函数，内部用模板实现核心逻辑，既能满足你非模板的要求，又能给部分场景消除类型擦除的开销。比如：

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

using namespace std;

// 内部模板实现，无类型擦除，编译器能内联比较逻辑
template<typename Func>
void sorter_impl(std::vector<int>& v, Func f){
    std::sort(v.begin(), v.end(), f);
}

// 对外的非模板函数，支持std::function
void sorter(std::vector<int>& v, std::function<bool(int, int)> f){
    sorter_impl(v, f);
}

// 重载支持无捕获Lambda转函数指针的情况，完全消除类型擦除开销
void sorter(std::vector<int>& v, bool(*f)(int, int)){
    sorter_impl(v, f);
}

int main()
{
    std::vector<int> v = {5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
    for (auto val : v)
        cout << val << " ";
    cout << endl;

    // 无捕获Lambda的情况，会走函数指针重载，无性能损耗
    auto f1 = [](int a, int b){ return a < b; };
    sorter(v, f1);

    // 有捕获Lambda的情况，走std::function版本
    int c = 4;
    auto f2 = [&c](int a, int b){ return a+b < c; };
    sorter(v, std::function<bool(int, int)>(f2));

    for (auto val : v)
        cout << val << " ";
    cout << endl;

    return 0;
}

这种方式下，无捕获的Lambda可以直接转成函数指针，调用重载的非模板函数，完全避开类型擦除的开销；有捕获的Lambda还是走std::function，但至少给常用的无捕获场景留了优化空间。

内容的提问来源于stack exchange，提问作者Kerim