La conversion entre les void * et un pointeur de fonction membre

Vous ne peut pas lancer un pointeur vers membre de void * ou de tout autre "régulier" de type pointeur. Les pointeurs-à-membres ne sont pas les adresses de la façon régulière les pointeurs sont. Ce que vous avez très probablement besoin de faire est d'envelopper votre fonction membre dans une fonction régulière. Le C++ FAQ Lite explique cette dans le détail. Le principal problème est que les données nécessaires pour mettre en œuvre un pointeur de membre n'est pas seulement une adresse, et en fait varie énormément basé sur le compilateur de mise en œuvre.

Je présume que vous avez le contrôle sur ce que les données de l'utilisateur lua_touserdata est de retour. Il ne peut pas être un pointeur-à-membre depuis il n'y a pas un moyen légal d'obtenir cette information. Mais vous n'avez d'autres choix:

• Le plus simple choix est probablement pour envelopper votre fonction membre dans une fonction libre et de retour que. Cette fonction doit prendre l'objet en tant que premier argument. Consultez l'exemple de code ci-dessous.

• Utiliser une technique similaire à celle de Coup de pouce.De Bind mem_fun pour retourner un objet de fonction, vous pouvez le modèle de façon appropriée. Je ne vois pas que c'est plus facile, mais ce serait vous permettent d'associer le plus avec le retour de la fonction si vous avez besoin de.

Voici une réécriture de votre fonction à l'aide de la première méthode:

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

OriginalL'auteur quark

Comme une solution de contournement, compte tenu des restrictions de la coulée d'un pointeur-à-membres de la fonction de void* vous pouvez rassembler le pointeur de fonction dans un petit tas-structure allouée et de mettre un pointeur vers cette structure dans votre Lua données de l'utilisateur:

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

Je ne suis pas calée avec Lua donc j'ai probablement oublié quelque chose dans l'exemple ci-dessus. Gardez à l'esprit, aussi, si vous suivez cette voie, vous devrez gérer la LuaUserData de l'allocation.

OriginalL'auteur fbrereto

Ici, il suffit de changer les paramètres de la fonction void_cast pour s'adapter à vos besoins:

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

exemple d'utilisation:

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

OriginalL'auteur Karlo Miličević