7

私の現在のプロジェクトでは、C/C++ から Lua へのラッパーをたくさん書いてきました。これらの多くは単純なセッターとゲッターであるため、これらを簡単に生成できるようにいくつかのテンプレートを作成することができました。

//        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_check などのテンプレート化されたラッパーをいくつか書きました。これらの既存のラッパーはすべてここにあります)

4

2 に答える 2

6

トリックは、ラッパー関数を含むクラス テンプレートを部分的に特殊化することで、テンプレートの引数推定を利用することです。

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

このコードは、オプション -c --std=c++0x を使用して G++ 4.6.1 でコンパイルされます。それが本当にあなたが望むことをするかどうかを見るために、それをテストしてください...

于 2012-08-17T13:07:29.580 に答える
2

この回答からのインデックス生成コードを再利用し、への関数呼び出しを無視すると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);
}
于 2012-07-21T11:18:03.167 に答える