如何在 C++11 中使用可变模板参数递归获取可变函数参数？

2016-5-3 11:0:56
收藏：0
阅读：55
评论：2

我正在使用 C++11 编写自己的 Lua 引擎，我想编写一个函数包装器，用于将 C++ 函数注册到 Lua 环境中，并支持可变参数。这在 C++0x 中很简单，但是我需要编写类似的代码，以支持具有 0 到 N 个参数的函数，这很烦人。 函数 push 用于将 T 推入 Lua 栈中，其中函数 upvalue_ 获取具有两个参数 T1 和 T2 的 C++ 函数指针，并假定该函数从 Lua 栈中获取 T1（索引 1）和 T2（索引 2）参数。

template <typename RVal, typename T1, typename T2>
struct functor<RVal,T1,T2>
{
    static int invoke(lua_State *L)
    {
        push(L,upvalue_<RVal(*)(T1,T2)>(L)(read<T1>(L,1),read<T2>(L,2)));
        return 1;
    }
};

template<typename T>
T upvalue_(lua_State *L)
{
    return user2type<T>::invoke(L, lua_upvalueindex(1));
}

使用 C++11，我编写了以下代码片段：

template< typename RVal, typename ... ARGS>
struct functor
{
    static int invoke(lua_State* L)
    {
        typedef RVal (*FUNC_PTR)(ARGS...);
        FUNC_PTR f = upvalue_<FUNC_PTR>(L);
        push(L, f(read_stack<ARGS>(L)...));
        return 1;
    }
};

template<typename T>
T read_stack(lua_State* L)
{
    T t = read<T>(L, -1);
    lua_pop(L, 1);
    return t;
}

上述代码可以工作，但是参数顺序是相反的，因为 read_stack 总是从最后一个索引 -1 中读取参数。 我的问题是如何使用可变模板参数从 1 到 N（如果 ARGS 不为空，则 N 等于 sizeof...(ARGS)）从 Lua 栈中读取参数，并将它们传递给实际的函数指针 f 进行实际调用？

点赞
用户6255513
用户6255513

不仅适用于 Lua，这里提供了一种通用的 C++11 解决方案，将给定参数的顺序反转传递给一个函数。在下面的代码中，“apply”是示例目标函数（这里只是基于其可变参数输出一些文本）。 “main”函数展示了helper函数“reverse_and_apply”如何接受一个函数（或者准确来说是一个仿函数）和一组参数，并且使用一些模板糊技巧将给定函数应用于反转的参数列表。请注意，我对完美转发的使用有些吹毛求疵，但它在技术上是正确的，但很遗憾，有些使代码难以理解。希望你能得到主要信息。

#include <iostream>

template <typename ...Args>
void apply(const char* fmtString, const Args&... args)
{
    char output[512];
    snprintf(output, 512, fmtString, args...);

    std::cout << output << std::endl;
}

template <typename F, typename ...Args>
struct ReverseAndApply;

template <typename F>
struct ReverseAndApply<F>
{
    template <typename ... AlreadyReversed>
    static void doIt(F func, AlreadyReversed&& ... args)
    {
        func(args...);
    }
};

template <typename F, typename FirstArg, typename ...RestArgs>
struct ReverseAndApply<F, FirstArg, RestArgs...>
{
    template <typename ... AlreadyReversed>
    static void doIt(F func, FirstArg&& arg, RestArgs&& ... restArgs, AlreadyReversed&& ... revArgs)
    {
        ReverseAndApply<F, RestArgs...>::doIt(func, std::forward<RestArgs>(restArgs)..., std::forward<FirstArg>(arg), std::forward<AlreadyReversed>(revArgs)...);
    }
};

template <typename F, typename... Args>
void reverse_and_apply(F func, Args&&... args)
{
    ReverseAndApply<F, Args...>::doIt(func, std::forward<Args>(args)...);
}

int main()
{
    reverse_and_apply(apply<double, const char*, int>, 1, (const char*)"abc", 2.0, "%f %s %d");
    return 0;
}
2016-05-03 10:50:37
用户1887915
用户1887915

你的 C++11 代码无法正常工作，因为参数的求值顺序未定义。在 C++14 中，可以通过使用 std::integer_sequence 来解决这个问题。

示例代码：

template< typename RVal, typename... ARGS>
struct functor
{
    template <std::size_t... Is>
    static int invoke_impl(lua_State *L, std::index_sequence<Is...>)
    {
        typedef RVal (*FUNC_PTR)(ARGS...);
        FUNC_PTR f = upvalue_<FUNC_PTR>(L);
        push(L, f(read<ARGS>(L, Is)...));
        return 1;
    }

    static int invoke(lua_State* L)
    {
        return invoke_impl(L, std::index_sequence_for<ARGS...>{});
    }
};
2016-05-03 18:47:05

作者:

用户5039473

用户5039473
推荐文章