能否不借助std::function获取C++ Lambda的捕获变量？

完全可以实现——Lambda本质是编译器生成的匿名闭包类，捕获的变量会作为该类的成员存在。我们可以通过模板或类型擦除技术，绕过std::function直接处理Lambda对象，同时实现自定义内存管理。

核心原理 #

Lambda在C++中是一个匿名的非union类类型，自带operator()方法，捕获的变量（值或引用）会成为这个类的成员变量。只要能持有这个匿名类的实例，就能访问其捕获的内容，也能自定义内存存储逻辑。

两种实现方案 #

方案一：模板版MyFunction（简单直接，无类型擦除） #

适合不需要多态兼容的场景，直接接收特定Lambda类型并存储：

#include <cstdio>
#include <utility>
#include <type_traits>

template<typename Func>
class MyFunction {
private:
    Func m_func; // 直接存储Lambda对象，包含所有捕获值

public:
    // 构造函数接收Lambda，支持移动
    explicit MyFunction(Func&& func) : m_func(std::move(func)) {}

    // 重载调用运算符，执行Lambda逻辑
    void operator()() {
        m_func();
    }

    // 示例：获取捕获值（通用做法是让Lambda暴露接口，避免依赖编译器实现）
    // 如果需要直接访问捕获成员，需注意不同编译器的命名规则（如GCC的__value、MSVC的$Capture$0）
    int get_captured_value() {
        // 这里假设Lambda捕获了int类型变量，通过Lambda内部暴露的方法获取
        return m_func.get_capture();
    }
};

// 推导指南，让编译器自动推导模板参数
template<typename Func>
MyFunction(Func&&) -> MyFunction<std::decay_t<Func>>;

int main(){
    int captureThis = 1;
    // 自定义Lambda，添加获取捕获值的方法
    auto lambda = [=]() mutable {
        printf("%i", captureThis);
    };
    // 扩展Lambda的接口（通过包装或继承，这里用简单的方式演示）
    struct WrappedLambda : decltype(lambda) {
        using Base = decltype(lambda);
        WrappedLambda(Base&& base) : Base(std::move(base)) {}
        int get_capture() { return this->Base::captureThis; } // 注意：编译器生成的成员名需对应实际情况
    };

    MyFunction func(WrappedLambda(std::move(lambda)));
    func(); // 输出1
    printf("\nCaptured value: %d", func.get_captured_value()); // 输出1
}

方案二：类型擦除版MyFunction（支持多态，自定义内存） #

如果需要像std::function一样兼容任意可调用对象，同时用自定义内存存储，可以用类型擦除封装调用逻辑：

#include <cstdio>
#include <utility>
#include <cstdlib>

// 自定义对齐内存分配器示例（16字节对齐）
struct CustomAllocator {
    void* allocate(size_t size) {
        return aligned_alloc(16, size);
    }

    void deallocate(void* ptr) {
        free(ptr);
    }
};

class MyFunction {
private:
    // 抽象基类，定义统一调用接口
    struct Concept {
        virtual ~Concept() = default;
        virtual void invoke() = 0;
    };

    // 具体实现类，存储Lambda对象
    template<typename Func>
    struct Model : Concept {
        Func m_func;
        explicit Model(Func&& func) : m_func(std::forward<Func>(func)) {}
        void invoke() override { m_func(); }
    };

    CustomAllocator m_alloc;
    Concept* m_ptr = nullptr;

public:
    // 构造函数：接收Lambda，用自定义内存分配并构造Model对象
    template<typename Func>
    MyFunction(Func&& func) {
        using ModelType = Model<std::decay_t<Func>>;
        m_ptr = static_cast<Concept*>(m_alloc.allocate(sizeof(ModelType)));
        new(m_ptr) ModelType(std::forward<Func>(func)); // 原地构造
    }

    // 析构函数：销毁对象并释放自定义内存
    ~MyFunction() {
        if (m_ptr) {
            m_ptr->~Concept();
            m_alloc.deallocate(m_ptr);
        }
    }

    // 禁用拷贝，支持移动
    MyFunction(const MyFunction&) = delete;
    MyFunction& operator=(const MyFunction&) = delete;

    MyFunction(MyFunction&& other) noexcept : m_ptr(other.m_ptr) {
        other.m_ptr = nullptr;
    }

    MyFunction& operator=(MyFunction&& other) noexcept {
        if (this != &other) {
            if (m_ptr) {
                m_ptr->~Concept();
                m_alloc.deallocate(m_ptr);
            }
            m_ptr = other.m_ptr;
            other.m_ptr = nullptr;
        }
        return *this;
    }

    // 重载调用运算符
    void operator()() {
        m_ptr->invoke();
    }
};

int main(){
    int captureThis = 1;
    MyFunction func([=]() {
        printf("%i", captureThis);
    });
    func(); // 输出1
}

关于std::function不支持分配器的原因 #

你的推测是对的，主要有两点：

1. 复杂度问题：std::function要兼容任意可调用对象，添加分配器需要处理不同类型的内存布局、异常安全和拷贝语义，实现成本极高。
2. 设计权衡：标准委员会认为，自定义内存管理的需求可以通过用户自行实现类型擦除来满足，没必要把复杂的分配器支持纳入标准。

注意事项 #

• 直接访问Lambda的捕获成员依赖编译器实现（不同编译器生成的成员名不同），通用场景下建议让Lambda主动暴露捕获值（如添加成员函数）。
• 自定义内存管理时必须严格遵守对齐要求，避免触发未定义行为。
• 类型擦除版本要正确处理移动、析构逻辑，防止内存泄漏。

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