1

假设我有以下情况：

namespace detail
{
    using duk_c_function_t = std::function<duk_ret_t(duk_context*)>;

    template<typename T_Return(typename ... T_Params), std::function<T_Return(T_Params)>
    duk_ret_t duk_function_proxy(duk_context* ctx)
    {
        const int n = sizeof...(T_Params); //real number of arguments passed.
        duk_idx_t num_arguments = duk_get_top(ctx); //Number of arguments from javascript
        int x = duk_require_int(ctx, 0); //Get integer -> parameter no 1
        const char* c = duk_require_string(ctx, 1); //Get string -> parameter no 2
    }
}
template<typename T_Return(typename ... T_Params)>
duk_c_function_t duk_function(std::function<T_Return(T_Params ...) function_item)
{
    return duk_c_function_t(detail::duk_function_proxy<function_item>);
}

Whereduk_function返回签名的函数duk_ret_t function(duk_context* ctx) { ... }。现在，我知道如何duk_function_proxy使用可变参数模板等调用函数对象。但是对我来说有一个问题：我使用的 javascript 解释器要求，对于我想要公开的每个 c 函数，我需要从堆栈中查询参数，如duk_function_proxy. 但是，在这种情况下，我不知道如何调用函数对象 - 我只能将查询的参数存储在某种容器中，因此我无法调用具有给定签名的函数对象。有没有办法将我查询的参数存储在某种容器中，然后解包并将其作为参数传递给函数对象？我根据可变参数模板列表查询所需的参数，如原型所示。

简而言之：

我想遍历 T_Params，使用duk_require_*（在某种容器中）获取和存储相应的变量，然后使用这些值调用作为模板参数传递的函数对象。

4

1 回答 1

1

这应该让你开始。我模拟了 DUK 界面，因为它没有安装在我的机器上，但你会明白的：

#include <iostream>
#include <string>
#include <functional>
#include <utility>

struct duk_context;

const char* duk_require_string(duk_context*, int i)
{
    static constexpr const char * strings[] = {
        "i like",
        "hairy",
        "ducks"
    };
    return strings[i];
}

int duk_require_int(duk_context*, int i)
{
    return i * 6;
}

template<class Type> auto get_arg(duk_context* ctx, int i) -> Type;

template<> auto get_arg<std::string>(duk_context* ctx, int i) -> std::string
{
    return duk_require_string(ctx, i);
}

template<> auto get_arg<int>(duk_context* ctx, int i) -> int
{
    return duk_require_int(ctx, i);
}

template<class...Args, size_t...Is>
void get_args_impl(duk_context* context, const std::function<void(Args...)>& f, std::index_sequence<Is...>)
{
    using tuple_type = std::tuple<Args...>;
    f(get_arg<std::tuple_element_t<Is, tuple_type>>(context, Is)...);
}

template<class...Args>
void get_args(duk_context* context, const std::function<void(Args...)>& f)
{
    get_args_impl<Args...>(context, f, std::index_sequence_for<Args...>());
}

void foo(std::string a, int b, std::string c)
{
    std::cout << a << " " << b << " " << c << std::endl;
}

int main()
{
    duk_context* ctx = nullptr;

    get_args(ctx, std::function<void(std::string, int, std::string)>(&foo));

    return 0;
}

预期输出：

i like 6 ducks
于 2016-02-15T01:12:15.047 回答