构造可变参数模板参数列表

Construct variadic template argument list

本文关键字：参数 列表 变参      更新时间：2023-10-16

假设我有以下情况： 

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>);
}

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

总之：

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

这应该让你开始。我已经模拟了 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
相关文章：