void* et fonctions membres

J'en étais resté à l'idée que void* pouvait représenter n'importe quel
pointeur, y compris de fonction. Mais voilà qu'avec des fonctions membres ça
ne marche pas :

-----
class Toto {
public:
bool foo();
} ;

bool bar();

typedef bool(Toto::*member_fun_ptr)();

typedef bool(*fun_ptr)();

int main(){
member_fun_ptr test=&Toto::foo;// typedef OK
void *ptr;
fun_ptr fp=&bar;

ptr=reinterpret_cast<void*>( fp );
fp=reinterpret_cast<fun_ptr>( ptr );

ptr=reinterpret_cast<void*>( &Toto::foo );
member_fun_ptr mfp=reinterpret_cast<member_fun_ptr>( ptr );
return 0;
}
-----

g++ me dit :
-----
In function ‘int main()’:
19:42: warning: converting from ‘bool (Toto::*)()’ to ‘void*’
[-Wpmf-conversions]
20:59: error: invalid cast from type ‘void*’ to type ‘member_fun_ptr {aka
bool (Toto::*)()}’
-----

Y a-t-il un moyen pour que ça fonctionne, et si oui comment ? Il me semble
que je pourrais remplacer void* par une union de tous les types de pointeurs
que j'utiliserai, mais c'est un peu lourdingue.

class Toto {
public:
bool foo();
} ;

bool bar();

typedef bool(Toto::*member_fun_ptr)();

typedef bool(*fun_ptr)();

int main(){
member_fun_ptr test=&Toto::foo;// typedef OK
void *ptr;
fun_ptr fp=&bar;

ptr=reinterpret_cast<void*>( fp );
fp=reinterpret_cast<fun_ptr>( ptr );

ptr=reinterpret_cast<void*>( &Toto::foo );
member_fun_ptr mfp=reinterpret_cast<member_fun_ptr>( ptr );
return 0;
}
-----

g++ me dit :
-----
In function ‘int main()’:
19:42: warning: converting from ‘bool (Toto::*)()’ to ‘void*’
[-Wpmf-conversions]
20:59: error: invalid cast from type ‘void*’ to type ⠀˜member_fun_ptr
{aka bool (Toto::*)()}’
-----

Y a-t-il un moyen pour que ça fonctionne, et si oui comment ? Il me
semble que je pourrais remplacer void* par une union de tous les
types de pointeurs que j'utiliserai, mais c'est un peu lourdingue.

Addendum, au cas où ça aide à résoudre le problè me : toutes les
fonctions sur lesquelles je prends un pointeur sont membres de la mê me
classe Toto.

Quelques éléments à :

https://isocpp.org/wiki/faq/pointers-to-members#cant-cvt-memfnptr-to-voidptr
http://stackoverflow.com/questions/1096341/function-pointers-casting-in-c

En résumé : c'est illégal, au mieux dépendant de l'implémentation.

C'est quoi "ça" (ce qui doit fonctionner) ?

Que peux-tu faire avec un pointeur de fonction/membre dont tu ne connais
pas le type ?

(Et si vraiment tu as du code qui doit fonctionner pour plusieurs types,
tu auras du mal à échapper aux template.)

https://isocpp.org/wiki/faq/pointers-to-members#cant-cvt-memfnptr-to-voi dptr
http://stackoverflow.com/questions/1096341/function-pointers-casting-in-c

En résumé : c'est illégal, au mieux dépendant de l'i mplémentation.

C'est quoi "ça" (ce qui doit fonctionner) ?

La même chose qu'avec une fonction globale ou tout autre objet :
pouvoir « caster » vers et depuis void*. Ça permet de stocker sous une
seule « forme » des pointeurs de différents types. (J e ne vois pas ce
qui pose problème pour une fonction membre si ça n'en pose pas pour
une fonction globale. Je suppose que je vais l'apprendre par les liens
que tu donnes.)

Que peux-tu faire avec un pointeur de fonction/membre dont tu ne
connais pas le type ?

Bien sûr je stocke aussi un index qui identifie le type de l'objet p ointé.

Par exemple j'aurais :
enum { A, B, C };
vector<int> type_objets;
vector<void*> objets;
...
switch(type_objets[i]){
case A:
typeA * objetA_ptr = reinterpret_cast<typeA*>(objets[i]);
...
case B:
...
}

A priori, ce n'est pas plus légal en C qu'en C++.

Par contre, si tu
utilises un type "pointeur de fonction" (p.ex void (*)(void *)), tu peux
caster entre types différents. Cf par exemple :

http://stackoverflow.com/questions/5579835/c-function-pointer-casting-to-void-pointer

L'idée est que les données (void *) et les fonctions (pointeurs de
fonction/membre) ne sont pas forcément stockées dans des zones de
mémoire de même nature, ne serait-ce qu'à cause de W^X. Donc les
deux types de pointeurs ne sont pas considérés comme compatibles.

Il me semble que ce que tu recherches est std::function, qui te permet
de conserver des "callables", que tu construis soit avec des lambdas,
soit avec std::bind, soit avec tes propres classes. Quelques infos à :

http://en.cppreference.com/w/cpp/utility/functional

A priori, ce n'est pas plus légal en C qu'en C++.

Même sans aller chercher le C (que je mélange car j'ai appris s ur le
tas, mais je compile avec g++), pourquoi les lignes suivantes ne
donnent-elles pas d'erreur ?
ptr=reinterpret_cast<void*>( fp );
fp=reinterpret_cast<fun_ptr>( ptr );

[...] W^X ?