Discussion :

[autre mickael]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
void onEach(word message);
void onFinished();
void onAck();
void onConf(word message);

et dans MetaPacket

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

[Flob90]

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

[autre mickael]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
typedef void (Probe::*f_no_arg)();
f_no_arg f_onFinished;

et dans le .c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

et dans le .c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

[Steph_ng8]

Bonjour.

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

(((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) ?

[autre mickael]

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.

[Steph_ng8]

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.

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 ?

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...