C++结合Duktape：如何将带参数的匿名Lambda传入duk_push_c_function

你遇到的编译错误本质是带捕获的Lambda无法隐式转换为普通函数指针。duk_c_function是标准的C函数指针类型（签名为duk_ret_t (*)(duk_context*)），而带捕获的Lambda会生成一个包含状态的匿名类实例，无法直接转成无状态的函数指针——只有无捕获的Lambda才能自动转换成对应的函数指针。

要让带捕获的Lambda在Duktape中工作，核心思路是把Lambda的状态（捕获的变量）存储在Duktape的虚拟机堆中，再通过一个静态包装函数作为中转，从堆中取出状态并调用Lambda。下面是两种实用实现方式：

方式一：用std::function封装Lambda（通用灵活） #

这种方式适合任意类型的Lambda，无需自定义结构体：

#include <duktape.h>
#include <functional>

// 静态包装函数，符合duk_c_function签名
static duk_ret_t lambda_wrapper(duk_context* ctx) {
    // 从Upvalue中取出存储的std::function
    auto func_ptr = static_cast<std::function<duk_ret_t(duk_context*)>*>(
        duk_get_upvalue(ctx, 0)
    );
    // 调用Lambda
    return (*func_ptr)(ctx);
}

// 封装的辅助函数：将带捕获的Lambda推送到Duktape栈
void duk_push_lambda(duk_context* ctx, std::function<duk_ret_t(duk_context*)>&& lambda) {
    // 用Duktape的内存分配器分配内存，确保能被GC跟踪
    auto func_ptr = static_cast<std::function<duk_ret_t(duk_context*)>*>(
        duk_alloc_raw(ctx, sizeof(std::function<duk_ret_t(duk_context*)>))
    );
    // 构造std::function，转移Lambda所有权
    new (func_ptr) std::function<duk_ret_t(duk_context*)>(std::move(lambda));

    // 将函数指针推为Upvalue，再推送包装函数并绑定Upvalue
    duk_push_pointer(ctx, func_ptr);
    duk_push_c_function(ctx, lambda_wrapper, 1); // 1是函数接受的参数个数
    duk_put_upvalue(ctx, -1, 0);

    // 设置Finalizer，GC时自动清理内存
    duk_push_c_function(ctx, [](duk_context* ctx) {
        auto func_ptr = static_cast<std::function<duk_ret_t(duk_context*)>*>(
            duk_get_upvalue(ctx, 0)
        );
        func_ptr->~function(); // 析构std::function
        duk_free_raw(ctx, func_ptr); // 释放内存
        return 0;
    }, 0);
    duk_set_finalizer(ctx, -2);
}

// 使用示例
int main() {
    duk_context* ctx = duk_create_heap_default();
    if (!ctx) return 1;

    SomeObjType parameter;
    // 初始化parameter...

    auto myLambda = [parameter](duk_context* ctx) {
        // 使用捕获的parameter执行逻辑
        duk_push_string(ctx, "Lambda executed with captured parameter");
        return (duk_ret_t)1;
    };

    // 将Lambda推送到Duktape栈，之后可以像普通C函数一样调用
    duk_push_lambda(ctx, std::move(myLambda));

    duk_destroy_heap(ctx);
    return 0;
}

方式二：自定义结构体存储捕获参数（轻量高效） #

如果只需要捕获固定类型的参数，直接用结构体存储更高效，避免std::function的开销：

#include <duktape.h>

// 存储捕获参数的结构体
struct CapturedData {
    SomeObjType parameter;
};

// 静态包装函数
static duk_ret_t wrapper(duk_context* ctx) {
    auto data = static_cast<CapturedData*>(duk_get_upvalue(ctx, 0));
    // 使用data->parameter执行逻辑
    duk_push_string(ctx, "Executed with captured data");
    return (duk_ret_t)1;
}

// 使用示例
int main() {
    duk_context* ctx = duk_create_heap_default();
    if (!ctx) return 1;

    SomeObjType parameter;
    // 初始化parameter...

    // 分配并初始化捕获数据
    auto data = static_cast<CapturedData*>(duk_alloc_raw(ctx, sizeof(CapturedData)));
    new (data) CapturedData{parameter}; // 复制构造参数

    // 绑定Upvalue并推送函数
    duk_push_pointer(ctx, data);
    duk_push_c_function(ctx, wrapper, 1);
    duk_put_upvalue(ctx, -1, 0);

    // 设置Finalizer清理内存
    duk_push_c_function(ctx, [](duk_context* ctx) {
        auto data = static_cast<CapturedData*>(duk_get_upvalue(ctx, 0));
        data->~CapturedData();
        duk_free_raw(ctx, data);
        return 0;
    }, 0);
    duk_set_finalizer(ctx, -2);

    duk_destroy_heap(ctx);
    return 0;
}

• 必须使用Duktape的内存分配函数（duk_alloc_raw/duk_free_raw），否则内存无法被Duktape的GC管理，会导致泄漏。
• 如果捕获的是指针/引用，要确保指向的对象生命周期覆盖Lambda的调用周期，避免悬空引用。
• duk_push_c_function的第三个参数是函数接受的JavaScript参数个数，根据实际需求调整。

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