Casting zwischen void * und einen Zeiger auf member-Funktion

Du kann nicht werfen einen Zeiger-auf-member void * oder zu jedem anderen "normalen" Zeiger-Typ. Zeiger-zu-member werden nicht korrigiert, wie regelmäßige Zeiger sind. Was Sie wahrscheinlich tun müssen, ist, wickeln Sie Ihre member-Funktion in einem regulären Funktion. Der C++ FAQ Lite dies erklärt in einigen Details. Das Hauptproblem ist, dass die Daten benötigt um einen Zeiger-auf-member ist nicht nur eine Adresse, und in der Tat variiert enorm basiert auf der compiler-Implementierung.

Ich nehme an, Sie haben die Kontrolle über das, was der Benutzer Daten lua_touserdata zurück. Es kann nicht ein Zeiger-auf-member-da gibt es keine rechtliche Möglichkeit, diese Informationen wieder aus. Aber Sie haben auch einige andere Möglichkeiten:

• Die einfachste Wahl ist wahrscheinlich zu wickeln Sie Ihre member-Funktion in einer freien Funktion und Rückkehr. Dass freie Funktion sollte das Objekt als erstes argument. Siehe das code-Beispiel unten.

• Verwenden eine Technik ähnlich der von Boost.Bind ' s mem_fun, um wieder eine function-Objekt, Sie können die Vorlage entsprechend auf. Ich sehe nicht, dass dies einfacher ist, aber es würde Sie verknüpfen die mehr Staat mit der Funktion zurück, wenn Sie Sie brauchte.

Hier ist ein umschreiben Ihrer Funktion mit der erste Weg:

template <class T>
int call_int_function(lua_State *L) 
{
    void (*method)(T*, int, int) = reinterpret_cast<void (*)(T*, int, int)>(lua_touserdata(L, lua_upvalueindex(1)));
    T *obj = reinterpret_cast<T *>(lua_touserdata(L, 1));

   method(obj, lua_tointeger(L, 2), lua_tointeger(L, 3));
   return 0;
}

InformationsquelleAutor quark

Als workaround angesichts der Beschränkungen der Umwandlung von einer Zeiger-auf-member-Funktion void* könnten Sie wickeln die Funktion Zeiger auf einen kleinen Haufen-reservierte Struktur und einen Zeiger auf das struct in Ihre Lua-user-Daten:

template <typename T>
struct LuaUserData {
    typename void (T::*MemberProc)(int, int);

    explicit LuaUserData(MemberProc proc) :
        mProc(proc)
    { }

    MemberProc mProc;
};

LuaObject<Foo> lobj = registerObject(L, "foo", fooObject);
LuaUserData<Foo>* lobj_data = new LuaUserData<Foo>(&Foo::bar);

lobj.addField(L, "bar", lobj_data);

//...

template <class T>
int call_int_function(lua_State *L) 
{
    typedef LuaUserData<T>                       LuaUserDataType;
    typedef typename LuaUserDataType::MemberProc ProcType;

    //this next line is problematic
    LuaUserDataType* data =
        reinterpret_cast<LuaUserDataType*>(lua_touserdata(L, lua_upvalueindex(1)));
    T *obj = reinterpret_cast<T *>(lua_touserdata(L, 1));

    (obj->*(data.mMemberProc))(lua_tointeger(L, 2), lua_tointeger(L, 3));
    return 0;
}

Ich bin nicht versiert mit der Lua so habe ich wahrscheinlich etwas übersehen im obigen Beispiel. Beachten Sie auch, wenn Sie diesen Weg gehen, müssen Sie zum verwalten der LuaUserData Zuweisung.

InformationsquelleAutor fbrereto

Hier ändern Sie einfach die Parameter der Funktion void_cast für Sie an Ihre Bedürfnisse anpassen:

template<typename T, typename R>
void* void_cast(R(T::*f)())
{
    union
    {
        R(T::*pf)();
        void* p;
    };
    pf = f;
    return p;
}

Beispiel verwenden:

auto pvoid = void_cast(&Foo::foo);

InformationsquelleAutor Karlo Miličević