如何使用可变模板来制作一个通用的Lua函数包装器

How to use variadic templates to make a generic Lua function wrapper?

本文关键字：一个 Lua 包装 函数 何使用      更新时间：2023-10-16

对于我当前的项目，我已经编写了很多C/C++到Lua包装器。其中很多都是简单的setter和getter，所以我设法编写了一些模板，使生成这些模板变得容易，比如：

//        Class       Return      Field
template <typename T, typename U, U T::*Member>
int luaU_get(lua_State* L)
{
    T* obj = luaW_check<T>(L, 1);
    luaU_push<U>(L, obj->*Member);
    return 1;
}
static luaL_reg Foo_Table[] =
{
    ...
    // Now I can just use this generic template to avoid
    // writing simple getter functions
    { "getbar", luaU_get<Foo, Bar, &Foo::bar> }, 
    ...
};

我也想为任意函数的简单函数包装器做一些类似的事情。例如，能够做到这一点会很好：

template <typename T, typename U, U (T::*Func)(), typename... Args>
int luaU_func(lua_State* L)
{
     // ...?
}
static luaL_reg Foo_Table[] =
{
    ...
    { "baz", luaU_func<Foo, int, &Foo::baz, int, float> }, 
    ...
};

这个想法是，当编译时，模板实际上是这样的：

int luaU_func(lua_State* L)
{
     luaU_push<int>(L, luaW_check<Foo>(L, 1)->baz(luaU_check<int>(L, 2), luaU_check<float>(L, 3)));
     return 1;
}

我只尝试过使用...扩展器，问题是要将整数值索引映射到正确的参数。我想不出让他们正常工作的方法。这样的事情可能吗？

（这里已经有点神奇了；我为lua_push和lua\heck之类的东西写了一些模板化的包装器。所有现有的包装器都可以在这里找到）

诀窍是通过部分专门化包含包装函数的类模板来利用模板参数推导：

// Lua API dummies ...
struct lua_State {};
template<class T> void luaU_push(lua_State*,T);
template<class T> T* luaW_check(lua_State*,int);
template<class T> T luaU_check(lua_State*,int);

// metaprogramming for creating indices ...
template<int...Ints>
struct int_pack {};
template<int Begin, int Count, int...Tail>
struct make_int_range_type {
    typedef typename make_int_range_type<Begin,Count-1,Begin+Count-1,Tail...>::type type;
};
template<int Begin, int...Tail>
struct make_int_range_type<Begin,0,Tail...> {
    typedef int_pack<Tail...> type;
};
template<int Begin, int Count>
inline typename make_int_range_type<Begin,Count>::type
make_int_range()
{ return typename make_int_range_type<Begin,Count>::type(); }

// the actual wrapper ...
template<class MemFunPtrType, MemFunPtrType PMF>
struct lua_mem_func_wrapper;
template<class Clazz, class ReturnType, class...Args, ReturnType(Clazz::*PMF)(Args...)>
struct lua_mem_func_wrapper<ReturnType(Clazz::*)(Args...),PMF> {
    static int doit(lua_State* L) {
        return doit_impl(L,make_int_range<2,sizeof...(Args)>());
    }
private:
    template<int...Indices>
    static int doit_impl(lua_State* L, int_pack<Indices...>) {
        luaU_push<ReturnType>(L,
            (luaW_check<Clazz>(L, 1)->*PMF)(
                luaU_check<Args>(L, Indices)...
            )
        );
        return 1;
    }
};
#define GET_MEM_FUN_WRAPPER(...) &lua_mem_func_wrapper<decltype(__VA_ARGS__),__VA_ARGS__>::doit

// testing ...
struct foo {
    int baz(int, float);
};
void test() {
    auto* ptr = GET_MEM_FUN_WRAPPER(&foo::baz);
}

此代码在G++4.6.1下使用选项-c--std=c++0x进行编译。要查看它是否真的符合您的要求，请测试它。。。

重复使用此答案中的索引生成代码，并忽略对Func的函数调用（不知道这到底是如何使用的），这就是它的样子：

template <typename T, typename U, U (T::*Func)(), 
          typename... Args, size_t... Idx>
int luaU_func_impl(lua_State* L, Collection<Idx...>)
{
   luaU_push<int>(L, luaW_check<U>(L, 1), luaU_check<Args>(L, Idx+2)...);
   return 1;
}
template <typename T, typename U, U (T::*Func)(), typename... Args>
int luaU_func(lua_State* L)
{
   typename GenerateCollection<Args...>::type Indices;
   return luaU_func_impl<T, U, Func, Args...>(L, Indices);
}
相关文章：