pointeurs de fonctions membres

Bonjour à tous,

Je découvre les joies du C++ dont ce soucis :

j'ai
-une classe Probe
-une classe MetaPacket
Probe contient un MetaPacket.

Le but est que quand j'appelle

Code:

---

1 2	mon_meta_packet.push(word message);

---

il puisse parfois m'appeler des méthodes de probe, j'ai donc dans Probe les fonctions qui peuvent être appelées:

Code:

---

1 2 3 4 5

void onEach(word message); void onFinished(); void onAck(); void onConf(word message);

---

et dans MetaPacket

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

void (*f_onEach)(word message); void (*f_onFinished)(); void (*f_onAck)(); void (*f_onConf)(word message); //le constructeur prend les pointeurs de fonction et les copies dans ses membres ... MetaPacket(void (*onEach)(word message), void (*onFinished)(), void (*onAck)(), void (*onConf)(word message)); //..pour les appeler dans push word push(word message) { //du code f_onAck(message); //encore du code }

---

jusque là ok mais quand j'appelle le constructeur de MetaPacket dans probe :

Code:

---

1 2 3 4

Probe::Probe() : m_meta(&Probe::onEach, &Probe::onFinished, &Probe::onAck, &Probe::onConf); { }

---

J'ai l'erreur suivante :
no matching function for call to ‘MetaPacket::MetaPacket(void (Probe::*)(word), void (Probe::*)(), void (Probe::*)(), void (Probe::*)(word))’
candidates are: MetaPacket::MetaPacket(void (*)(word), void (*)(), void (*)(), void (*)(word))

Il y a plusieurs probes donc je ne veux pas que les fonctions on* soient statiques, je souhaite juste que chaque push sur une sonde (sur son metapacket) puisse éventuellement appeler les fonctions on* sur cette même sonde.
J'ai essayé sans "&Probe::" qui me semblerait plus logique mais rien à faire, c'est un <unresolved overloaded function type> 0_o
Je suis preneur pour un petit eclaircissement, merci beaucoup !

Un pointeur de fonction membre son type c'est ReturnType (Class::*)(ParamTypes), donc quand tu lui donnes une pointeur de fonction membre et qu'il attend juste un pointeur de fonction (ie un objet de type ReturnType (*)(ParamTypes)) il te dit que ce n'est pas bon. Il faut que tu corriges en conséquence ton code :ccool:

Ahh, merci, on se raproche.
Cela fonctionne pour une fonction sans argument :
dans le MetaPacket.h :

Code:

---

1 2 3

typedef void (Probe::*f_no_arg)(); f_no_arg f_onFinished;

---

et dans le .c :

Code:

---

1 2	(((MetaPacket*)this)->MetaPacket::f_onFinished);

---

en revanche, en bidouillant quelque chose similaire pour une fonction avec un argument :
dans le .h

Code:

---

1 2 3

typedef void (Probe::*f_one_arg)(word message); f_one_arg f_onEach;

---

et dans le .c :

Code:

---

1 2	(((MetaPacket*)this)->MetaPacket::f_onEach)(packet->in.pMsg.message);

---

ca me donne :
error: must use ‘.*’ or ‘->*’ to call pointer-to-member function in ‘((MetaPacket*)this)->MetaPacket::f_onEach (...)’, e.g. ‘(... ->* ((MetaPacket*)this)->MetaPacket::f_onEach) (...)’

si je modifie en :

Code:

---

1 2	(((MetaPacket*)this)->*((MetaPacket*)this)->MetaPacket::f_onEach)(packet->in.pMsg.message);

---

et ben c'est incompatible :
error: pointer to member type ‘void (Probe:: )(word)’ incompatible with object type ‘MetaPacket’.
Merci pour le coup de pouce, j'espère que tu en as un deuxième :D !

Bonjour.

Inutile de nommer les arguments pour le type « pointeur de fonction ».

Code:

---

typedef void (Probe::*f_one_arg)(word);

---

Essaie de mettre une * pour déréférencer le pointeur sur fonction.
Parfois ça marche sans, parfois c'est indispensable.
J'avoue que j'ai un peu de mal à comprendre comment ça fonctionne (même si logiquement, l'étoile devrait toujours être présente...).

Code:

---

(((MetaPacket*)this)->*MetaPacket::f_onEach)(packet->in.pMsg.message);

---

Sinon, vu que tu fais du C++, utilise les opérateurs de transtypage du C++.
F.A.Q. C++: Comment effectuer une conversion de type explicite (cast) ?

ok, merci pour la question du typedef.
Pour le reste : c'est pas mieux. Après, je suis en train d'appeler une fonction membre de Probe dans la classe MetaPacket, c'est pas vraiment normal (si ?). Je pense que je vais tout simplement faire hériter probe de MetaPacket et mes fonctions on* serait virtuelle pure dans MetaPacket et surdéfinies dans Probe et roule ma poule !
C'est la première fois que je taperai le mot "virtual" donc peut-être n'ai-je pas tout compris. Ca peut fonctionner ?
merci.

Citation:

---

Envoyé par autre mickael

Après, je suis en train d'appeler une fonction membre de Probe dans la classe MetaPacket, c'est pas vraiment normal (si ?).

---

À la réflexion, c'est en effet plutôt étrange...
Je n'avais pas vraiment regardé ton code en détails, et du coup j'étais passé à côté de ça.
S'il n'y a aucun lien d'héritage entre les deux classes, tu ne devrais pas être autorisé à faire cela.

Citation:

---

Envoyé par autre mickael

Je pense que je vais tout simplement faire hériter probe de MetaPacket

---

Attention, il ne faut pas voir l'héritage comme un moyen simple de faire quelque chose de complexe (ou compliqué...).
Il ne faut créer une relation d'héritage que s'il y a une bonne raison de le faire (relation « est-un » ou « est implémenté en termes de »).
Est-ce vraiment le cas ici ?

Citation:

---

Envoyé par autre mickael

et mes fonctions on* serait virtuelle pure dans MetaPacket et surdéfinies dans Probe et roule ma poule !
C'est la première fois que je taperai le mot "virtual" donc peut-être n'ai-je pas tout compris. Ca peut fonctionner ?
merci.

---

Hum, ça va probablement fonctionner.
Mais le problème sera au niveau de la conception, comme indiqué au-dessus.


Tu peux essayer de faire un lien entre un objet MetaPacket et son « parent » en ajoutant une référence ou un pointeur vers un Probe comme donnée membre de la classe MetaPacket.
Ainsi, quand tu veux invoquer une fonction membre, tu as directement accès à l'objet cible.

Je ne sais pas si ça fera ce que tu attends, mais c'est une idée.
En tout cas, au vu de ce que j'ai compris, c'est ce qui me paraît le plus raisonnable, puisque de toute façon, il te faut l'objet cible pour exécuter la fonction membre.

Ou alors, tu peux garder les pointeurs sur fonction, mais passer en paramètre l'objet cible.
Ou encore passer en paramètres à la fois l'objet cible et un pointeur sur la fonction que tu veux appliquer...

Oh ouais, pas mal, merci !
C'est assez simple en fait, quand j'initialise le metapacket contenu dans probe, le lui donne un pointeur vers le Probe "conteneur", puis au lieu d'appeler une fonction membre dans une autre classe, je me met pour de bon à la POO et je fait dans MetaPacket:

Code:

---

1 2	my_probe->onEach(my_message);

---

Merci beaucoup, ca va m'éviter bien des complications inutiles.