1

これは、C++クラスをLuaに公開することを扱う私の実際のコードの一部です。

#include <lua5.1/lua.hpp>
#include <tuple>

//in actual code, lots of specializations of these C++<=>Lua's stack helper functions. Here it's just a sample.
template<typename T> T to(lua_State*, int);
template<> int to(lua_State* l, int i){
    return lua_tointeger(l, i);
}
template<typename T> void push(lua_State*, T);
template<> void push(lua_State* l, int val){
    lua_pushinteger(l, val);
}

//in actual code, placed in a header
template<typename T, T> class function_proxy{
    static_assert(sizeof(T)!=sizeof(T), "Error: function_proxy works with functions (duh)");
};

template<typename Return, typename... Args, Return(*func)(Args...)> class function_proxy<Return(*)(Args...), func>{
    static Return call(lua_State* l, Args... args){
        return func(args...);
    }
    template<typename... retrieved> static Return call(lua_State* l, retrieved... read){
        return call(l, read..., to<typename std::tuple_element<sizeof...(read), std::tuple<Args...> >::type >(l, 1+sizeof...(read)));
    }
public:
    static int wrapper(lua_State* l){
        push(l, call(l));
        return 1;
    }
};

//in actual code, inner class of a template class in another header
template<typename CT, CT> class member_helper{
    static_assert(sizeof(CT)!=sizeof(CT), "Error: member_helper works with members of T (duh)");
};
//Just one of the actual partial specializations, to combine constness and the return of void or non-void
template<typename Class, typename Return, typename... Args, Return(Class::*fun)(Args...)> struct member_helper<Return(Class::*)(Args...), fun>{
    static Return as_free(Class& obj, Args... args){
        return (obj.*fun)(args...);
    }
    static int worker(lua_State* l, Class& obj, bool is_const, bool write){
        if(write) throw "Cannot write a member function.";
        //ERROR HERE: template argument 2 is invalid. Not very helpful message.
        lua_pushcclosure(l, function_proxy<decltype(&as_free), &as_free>::wrapper, 0);
        return 1;
    }
};

struct Test{
    int test(int arg){ return arg*3; }
};

int test_as_free(int arg){ return arg*3; }

int main(){
    lua_State* l=luaL_newstate();
    Test t;
    //works fine
    lua_pushcclosure(l, function_proxy<decltype(&test_as_free), &test_as_free>::wrapper, 0);
    //does not work
    member_helper<decltype(&Test::test), &Test::test>::worker(l, t, false, false);
}

function_proxy<decltype(&as_free), &as_free>::wrapperで非常によく似たことが行われていても、ポインタを取得するときにコードが失敗しますmain。静的メンバー関数ではなく、free関数のポインターを取得することに違いはないと思います。これはこのg++バグのインスタンスですか（私がコンパイルし-std=c++0xたところ、バグはC ++ 11で修正されたようです）？

4

2 に答える 2

2

これはg++のバグであり、確認されています。

于 2012-04-16T18:33:09.853 に答える
0

完全には理解していませんが、Classをdecltype（＆Test :: test）にし、Returnを＆Test :: testにしますか？私にとっては、次のようになります。

member_helper<Test, int>::worker

ただし、あるタイプの間接参照を次々に追加して、作業ラインから非作業ラインに移行するのはどうでしょうか。

于 2012-04-16T14:57:15.570 に答える