C++11 如何在c+中用可变模板参数递归获取可变函数参数+；11? 我正在用C++ 11来开发自己的Lua引擎，我想用一个函数来包装一个函数，用可变参数将C++函数登记到Lua环境中。这是简单的C++ 0x，但枯燥的原因，我需要编写类似的代码支持函数的0个N参数。 函数推用来将T推到Lua栈，其中函数UpValueVy+Lua Cc++得到C++函数指针，假设函数有两个参数T1和T2，T1从索引1中提取，L2栈从索引2中获取T2。 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)); } 模板 结构函子 { 静态int调用（lua_State*L） { push（L，upvalue_u1）（读（L，1），读（L，2））； 返回1； } }; 模板 T上升值（lua_状态*L） { 返回user2type:：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; } template 结构函子 { 静态int调用（lua_State*L） { typedef RVal（*FUNC_PTR）（参数…）； FUNC_PTR f=upvalue_L； 推送（L，f）（读栈（L）…）； 返回1； } }; 模板 T读取堆栈（lua\U状态*L） { T=读数（L，-1）； 卢厄波普（L，1）； 返回t； }

上面显示的代码可以工作，但参数顺序相反，因为read_stack始终从最后一个索引-1读取参数。

---

我的问题是如何使用可变模板参数从lua堆栈1读取参数到N（N等于sizeof…（ARGS），如果ARGS不为空），并将其传递给实函数指针f以进行实调用？

不是lua特有的，下面是一个通用C++11解决方案，用于将给定参数的顺序反转到函数。在下面的代码中，“apply”是我的示例目标函数（这里它只是根据可变参数输出一点文本）。“main”函数显示了辅助函数“reverse_and_apply”如何获取一个函数（确切地说是函子）和一组参数，并使用一些模板技巧将给定函数应用于反向参数列表。请注意，我为这里使用的perfect forwarding（完美转发）在技术上是正确的，但不幸的是，它在某种程度上混淆了代码，对此我深表歉意。希望你能得到主要信息

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

#包括
模板
无效应用（常量字符*fmtString、常量参数和…参数）
{
字符输出[512]；
snprintf（输出，512，fmtString，args…）；
std:：cout不是Lua特有的，这里是一个通用的C++11解决方案，用于将给定参数的顺序反转为函数。在下面的代码中，“apply”是我的示例目标函数（这里它只是根据其可变参数输出一点文本）。“main”函数显示了辅助函数“reverse\u and\u apply”如何获取函数（或者更准确地说是Functor）和一组参数，并使用一些模板技巧将给定函数应用于反向参数列表。注意，我为这里使用的perfect forwarding（完美转发）在技术上是正确的，但不幸的是，它在某种程度上混淆了代码。希望您能理解主要信息

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

#包括
模板
无效应用（常量字符*fmtString、常量参数和…参数）
{
字符输出[512]；
snprintf（输出，512，fmtString，args…）；
std:：cout您在C++11中的代码甚至不能工作，因为参数的求值顺序没有定义。
在C++14中使用应该很容易

示例代码：

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

template
结构函子
{
模板
静态int invoke_impl（lua_State*L，std:：index_序列）
{
typedef RVal（*FUNC_PTR）（参数…）；
FUNC_PTR f=upvalue_L；
推（L，f）（读（L，Is）…）；
返回1；
}
静态int调用（lua_State*L）
{
返回invoke_impl（L，std:：index_sequence_for{}）；
}
};
您在C++11中的代码甚至无法工作，因为未定义参数的求值顺序。
在C++14中使用应该很容易

示例代码：

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

template
结构函子
{
模板
静态int invoke_impl（lua_State*L，std:：index_序列）
{
typedef RVal（*FUNC_PTR）（参数…）；
FUNC_PTR f=upvalue_L；
推（L，f）（读（L，Is）…）；
返回1；
}
静态int调用（lua_State*L）
{
返回invoke_impl（L，std:：index_sequence_for{}）；
}
};
如果read_stack get参数总是从1开始，它可能工作：template T pop（lua_State*L）{T T=read（L，1）；lua_remove（L，1）；//删除第一个参数返回T；}也许这有一个解决方案或想法：。如果read_stack get参数总是从1开始，它可能工作：template T pop（lua_State*L）{T T=read（L，1）；lua_remove（L，1）；//删除第一个参数return T；}也许这有一个解决方案或想法：。