Cast à fonction membre pointeur normal

Question

Actuellement, j'ai une classe de ce genre, raccourci pour la simplicité:

class MyClass { 
    public: 
     MyClass(); 
     void* someFunc(void* param); 
} 

Maintenant je dois appeler une fonction de ce genre (non membre d'une classe et que je malheureusement ne peut pas changer) mais que je dois appeler de toute façon:

void secondFunc(int a, int b, void *(*pCallback)(void*)); 

maintenant je dois passer l'adresse de someFunc d'une instance.

Un échantillon ne fonctionne pas:

MyClass demoInstance; 
// some other calls 
secondFunc(1, 2, demoInstance::someFunc()); 

J'ai essayé aussi avec des moulages comme:

(void* (*)(void*)) demoInstance::someFunc; 
reinterpret_cast<(void* (*)(void*))>(demoInstance::someFunc); 

Comment puis-je appeler cette fonction avec une classe fonction de membre en tant que paramètre de sorte que celui-ci peut l'utiliser comme rappel?

Toute idée ou remarque est appréciée. Merci et salutations tobias

Answer 1

La différence entre une fonction C et une fonction membre C++ est que la fonction C utilise cdecl convention d'appel, tandis que les fonctions de membre utilise thiscall convention d'appel (et vous ne pouvez pas même prendre leur adresse!). Si je comprends bien, vous voulez que secondFunc() appelle la fonction membre d'une instance particulière de la classe (appelons-le this).Eh bien, les adresses des fonctions membres de toutes les instances d'une classe particulière sont les mêmes. Pour passer le pointeur à l'objet, vous aurez besoin d'un canal latéral. Dans ce cas, il pourrait s'agir d'une variable statique. Ou, si vous voulez le support MT, vous devrez utiliser le stockage local de thread (TLS),

Cela nécessite un callback par membre de type SomeFunc, mais vous auriez besoin d'un répartiteur quelque part de toute façon.

Answer 2

Vous ne pouvez pas appeler la fonction membre directement. Les pointeurs de fonction membre ne sont pas du même type que les pointeurs de fonction.

Vous devrez envelopper d'une manière ou d'une autre une fonction compatible. Cependant, si votre fonction externe (celle qui prend le pointeur de fonction comme argument) n'est pas re-entrant et ne fournit pas un argument supplémentaire à utiliser par le pointeur de fonction, vous ne serez pas en mesure de passer l'instance sur laquelle le membre fonction fonctionne, de sorte que vous ne serez pas en mesure de faire l'appel.

Answer 3

class MyClass 
{ 
public: 
    MyClass(); 
    void* someFunc(void* param); 
}; 

void* callback(void*) 
{ 
    MyClass instance; 
    instance.someFunc(0 /* or whatever */); 
} 

void foo() 
{ 
    secondFunc(1, 2, callback); 
} 

Answer 4

N'a pas vu la partie de ne pas être en mesure de changer la deuxième fonction avant.

Définir une structure avec des pointeurs à la fonction de membre et à l'objet:

struct MyData { 
    MyStruct *myInstance; 
    (void *)(MyStruct::myFunction)(void *data); 
    void * dataPointer ; 
} 

créer une fonction qui peut appeler la méthode appropriée:

void *proxyFunc(MyData *data) 
{ 
    return (data->myInstance->*(data->myFunction))(data->dataPointer); 
} 

appeler ensuite la fonction 2 comme:

MyData dataP = { someInstance, &MyStruct::someFunc, &dataPtr }; 
secondFunc(proxyFunc, &dataP); 

Answer 5

Il existe un moyen de contourner ce problème. Puisque les noms C++ sont modifiés, vous ne pouvez pas l'utiliser directement pour des fonctions non statiques. Cependant, comme les fonctions non statiques ont les mêmes signatures que les fonctions C, vous pouvez les utiliser directement comme callbacks. Donc, pour les fonctions non statiques, vous pouvez avoir des wrappers de fonctions statiques. This page explique cette approche en détail.

Answer 6

Voir cet exemple:

#include <iostream> 

class MyClass 
{ 
public: 
    MyClass() 
    { 
    } 

    void* someFunc(void* param) 
    { 
     std::cout << "someFunc" << std::endl; 
     return (void*)0; 
    } 
}; 

typedef void* (MyClass::*MemFun)(void*); 

void secondFunc(int a, int b, MemFun fn) 
{ 
    MyClass* ptr = 0; 
    // This is dangerous! If the function someFunc do not operate the data in the class. 
    // You can do this. 
    (ptr->*fn)(0); 
    std::cout << "Call me successfully!" << std::endl; 
} 

int main() 
{ 
    secondFunc(1, 2, &MyClass::someFunc); 

    system("pause"); 

    return 0; 
}