声明带引用捕获的Lambda函数数组是否会引发堆分配？

为什么会出现堆分配？ #

问题核心在于std::function的类型擦除机制和小缓冲区优化（SBO）：

• std::function是通用可调用对象包装器，为了兼容任意类型的可调用对象（Lambda、函数指针、 functor等），会对底层对象做类型擦除处理。
• 为避免频繁堆分配，std::function内部预留了一块栈上的小型缓冲区（SBO）。如果被包装的可调用对象的大小和对齐要求不超过缓冲区阈值，就直接在栈上存储；反之则必须在堆上分配内存存放该对象。

带引用捕获的Lambda，其对象大小由捕获的引用数量决定——每个引用捕获在Lambda对象中以指针形式存储（底层等价于指针）。当捕获的引用数量较多时，Lambda总大小很容易超过std::function的SBO阈值（不同编译器实现的阈值不同，常见为16或32字节），这时就会触发堆分配。

比如：若编译器给std::function<void()>的SBO是16字节，某个Lambda捕获了3个8字节的引用（总大小24字节），就会超出缓冲区，引发堆分配。

如何重构避免堆分配？ #

方案1：用std::variant存储不同类型的Lambda #

每个Lambda都是独立类型，用std::variant封装这些类型后，std::array存储的变体对象会在栈上分配足够空间容纳最大的Lambda，完全无需堆分配。

示例代码：

// 直接定义带引用捕获的Lambda，用auto推导类型（不要转成std::function）
auto func1 = [&a, &b]() { /* 业务逻辑实现 */ };
auto func2 = [&c, &d, &e]() { /* 业务逻辑实现 */ };
auto func3 = [&f]() { /* 业务逻辑实现 */ };

// 定义包含所有Lambda类型的变体类型
using FuncVariant = std::variant<decltype(func1), decltype(func2), decltype(func3)>;

// 构建栈上存储的数组
std::array<FuncVariant, 3U> func_array{ func1, func2, func3 };

// 调用时用std::visit触发对应Lambda执行
for (auto& func_var : func_array) {
    std::visit([](auto&& func) { func(); }, func_var);
}

方案2：控制Lambda大小适配SBO #

如果业务场景允许，可减少Lambda捕获的引用数量，或把多个引用包装到一个结构体中、仅捕获该结构体的引用，让Lambda总大小控制在std::function的SBO阈值内。这种方式依赖编译器具体实现，通用性较差，但固定环境下可快速解决问题。

方案3：静态多态（CRTP）封装 #

若所有Lambda的行为可抽象出统一接口，可用CRTP实现静态多态，避免类型擦除带来的堆分配。不过这种方式代码复杂度较高，适合大量重复调用的场景：

// 静态多态基类
template<typename Derived>
class FuncBase {
public:
    void operator()() {
        static_cast<Derived*>(this)->invoke();
    }
};

// 封装原func1为CRTP子类
class Func1 : public FuncBase<Func1> {
private:
    int& a;
    float& b;
public:
    Func1(int& a_ref, float& b_ref) : a(a_ref), b(b_ref) {}
    void invoke() { /* 原func1的业务逻辑 */ }
};

// 同理封装Func2、Func3...

// 数组存储基类指针（需注意对象生命周期）
std::array<std::unique_ptr<FuncBase>, 3U> func_array{
    std::make_unique<Func1>(a, b),
    std::make_unique<Func2>(c, d, e),
    std::make_unique<Func3>(f)
};

// 调用函数
for (auto& func_ptr : func_array) {
    (*func_ptr)();
}

内容的提问来源于stack exchange，提问作者Ekrem Kılıç