性能敏感场景下，如何不使用std::function传递带捕获的lambda？

报错原因 #

带捕获的Lambda本质是包含捕获成员变量的匿名类实例，而普通函数指针无法存储任何状态——只有无捕获的Lambda才能隐式转换为函数指针。你的代码中Lambda捕获了x，因此无法转换成void (*)(int, int, int)类型，导致编译报错。

性能友好的解决方案 #

方案1：自定义函数对象类（无需模板） #

既然参数和返回类型固定，可手动实现包含捕获状态的函数对象类，完全规避std::function的开销：

#include <iostream>

class MyCallback {
public:
    // 构造函数传入需要捕获的变量（与Lambda的&捕获逻辑一致）
    MyCallback(int& x) : x_(x) {}

    // 重载()运算符实现回调逻辑
    void operator()(int a, int b, int c) const {
        std::cout << "Example, a + b + c + x: " << a + b + c + x_ << std::endl;
    }

private:
    int& x_; // 存储捕获的引用
};

// 接收函数对象引用，避免不必要的拷贝
void my_func(const MyCallback& callback) {
    callback(1, 2, 3);
}

int main() {
    int x = 10;
    my_func(MyCallback(x));
    return 0;
}

该方案完全满足“不使用模板”的要求，性能与Lambda一致，无额外运行时开销。

方案2：模板参数接收Lambda（性能最优） #

若能接受模板，这是最简洁且性能最优的方案——编译器会对模板进行特化，直接生成对应Lambda的调用代码，几乎零开销：

#include <iostream>

// 模板参数接收任意可调用对象（包括带捕获的Lambda）
template<typename Callback>
void my_func(Callback callback) {
    callback(1, 2, 3);
}

int main() {
    int x = 10;
    my_func([&](int a, int b, int c) {
        std::cout << "Example, a + b + c + x: " << a + b + c + x << std::endl;
    });
    return 0;
}

这种写法在性能敏感场景非常常见，编译器通常会将回调逻辑内联到my_func中，彻底消除函数调用的开销。

补充：C++20可选方案（若项目支持） #

如果你的项目基于C++20，可使用std::move_only_function，它比std::function的开销更小（简化了小对象优化逻辑），适合需要类型擦除但想降低开销的场景：

#include <iostream>
#include <functional>

void my_func(std::move_only_function<void(int, int, int)> callback) {
    callback(1, 2, 3);
}

int main() {
    int x = 10;
    my_func([&](int a, int b, int c) {
        std::cout << "Example, a + b + c + x: " << a + b + c + x << std::endl;
    });
    return 0;
}

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