Problème d'appel de fonction dans une classe

Bonjour à toutes et à tous,

Je suis désolé, mais la présentation de mon problème est un peu longue. Merci d'avance à ceux qui auront le courage d'aller jusqu'au bout.

J'ai une classe de composant visuel :

Code:

---

1 2 3 4 5

Class Comp { ... void(*surAppui)(boolean); virtual boolean select(int x, int y); }

---

Dans son constructeur, "surAppui = NULL". La fonction "select" est la suivante :

Code:

---

1 2 3 4 5

Comp::select(int x, int y) { if (x et y dans la zone d'appui sur le composant) if (surAppui != NULL) surAppui(un boolean); // je renvois sur une fonction qui va faire ce que je veux }

---

Cette fonction "surAppui" a le même mécanisme que le "onClick" dans Windows par exemple.

J'ai créé des enfants de "Comp", par exemple "Bouton".

Maintenant, à l'utilisation, j'instancie une classe "Bouton monBouton" et j'affecte à "surAppui" une fonction "quoiFaire" :

Code:

---

1 2 3 4 5

monBouton.surAppui = &quoiFaire;   void quoiFaire(boolean a) { //Exécute ce que j'ai envie de faire }

---

Tout ce mécanisme fonctionne très bien, mais maintenant, je voudrais que ce mécanisme fonctionne à l'intérieur de mes classes.

J'ai créé une classe "Page" descendant de "Comp" et utilisant "Bouton" :

Code:

---

1 2 3 4 5 6 7 8

class Page : public Comp { Bouton btn1; void chgtPage(boolean); // la fonction que veux associer à "surAppui" virtual boolean select(int x, int y); // modifie le comportement de la classe de base Page(les params qui vont bien) : btn1(ses params) { btn1.surAppui = &chgtPage // l'affectation de "chgtPage" à "surAppui" } }

---

Alors que la construction de ce lien est semblable à celui qui fonctionne, c'est sur cette dernière instruction que le compilateur n'est pas d'accord. Il me renvoit l'erreur suivante :

Code:

---

1 2 3 4 5 6

MaClasse.cpp:13:24: error: ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function. Say '&Page::chgtPage' [-fpermissive] btn1.surAppui = &chgtPage; ^ MaClasse.cpp:13:21: error: cannot convert 'void (Page::*)(boolean) {aka void (Page::*)(bool)}' to 'void (*)(boolean) {aka void (*)(bool)}' in assignment btn1.surAppui = &chgtPage; ^

---

Voilà, j'ai toujours été mal à l'aise avec ce genre de message. Si vous pouviez m'aider à trouver ce qui cloche.

Merci de votre aide.

Pierre

Ton compilateur te dit explicitement ce qui ne va pas :mrgreen: :mrgreen:

En C++, cela s'appelle un pointeur de fonction membre -> :google:

En gros :mrgreen:, il faut à chaque fois surspécifié ton pointeur void (*) (bool) (1) est différent de void (Page::*) (bool) (2)

1. C'est un pointeur de fonction
2. C'est un pointeur de fonction membre de la classe Page

Et en plus de cela un pointeur de fonction membre a un appel très spécifique en .* ou ->* Par exemple (this->*pointer) (true).

Une fonction membre de classe contient un paramètre caché : L'objet sur lequel cette fonction est appelée. Donc ce n'est pas directement compatible avec une fonction libre.
Tu pourrais remplacer ton pointeur sur fonction libre par un pointeur sur fonction membre (avec une syntaxe assez horrible que je vais t'épargner, mais qui apparaît dans ton message d'erreur), mais alors tu ne pourrais plus utiliser de fonction libre.

Déclaration

Donc comment faire ? Il suffit de passer un objet qui peut encapsuler soit une fonction libre, soit une fonction membre, soit d'autres choses encore (en gros, tout ce qui peut être suivi par des parenthèses avec un booléen dedans, un appelle ça un foncteur en C++). Cet objet existe en standard en C++, mais il y a deux manières d'écrire le code :

1/ Si la fonction à appeler est connue à la compilation (c'est généralement le cas d'un algorithme configurable), on utilise un template et on laisse faire le compilateur :

Code:

---

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

template<class Filtre> void afficheAvecFiltre(vector<int> const &v, Filtre filtre) { for(auto i : v) { if(filtre(i)) cout << i << endl; } }   bool estPair(int i) { return (i%2) == 0; }   void f(vector<int> const &v) { afficheAvecFiltre(v, estPair); }

---

2/ Si la fonction n'est pas connue à la compilation, et peut varier au cours du temps, on utilise std::function (on perd en perfs par rapport au cas précédent, mais on gagne en flexibilité) :

Code:

---

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

Class Comp { ... std::function<void(bool)> surAppui; virtual boolean select(int x, int y) { if (x et y dans la zone d'appui sur le composant) if (surAppui) surAppui(un boolean); // je renvois sur une fonction qui va faire ce que je veux } }   void quoiFaire(boolean a) { //Exécute ce que j'ai envie de faire }   monBouton.surAppui = quoiFaire;

---

Utilisation
L'utilisation pour une simple fonction est triviale, comme indiqué plus haut. Pour une fonction membre, c'est un peu plus complexe. Il faut indiquer sur quel objet on va appliquer la fonction. Et on ne peut pas passer cet objet en paramètre, puisque notre seul paramètre au moment de l'appel est un booléen. Il faut donc qu'au moment où on crée notre foncteur, on lie à celui-ci l'objet sur lequel appeler la fonction. Il y a plusieurs manières d'y arriver, plusieurs écritures qui ont varié au cours du temps. Actuellement, je préfère utiliser les lambdas pour faire ça. Par exemple :

Code:

---

1 2 3 4 5 6 7 8

class Page : public Comp { Bouton btn1; void chgtPage(boolean); // la fonction que veux associer à "surAppui"   Page(les params qui vont bien) : btn1(ses params) { btn1.surAppui = [this](bool b) {chgtPage(b); }; // l'affectation de "chgtPage" à "surAppui" } }

---

Je vous remercie tous les deux pour ces réponses ... dont le niveau me dépasse. Je vais essayer de décortiquer tout cela, mais en attendant :

@JolyLoic : j'ai simplement remplacé l'instruction :

Code:

---

btn1.surAppui = &chgtPage;

---

par

Code:

---

btn1.surAppui = [this](boolean b) {chgtPage(b); };

---

Apparemment, cela ne suffit pas car j'ai cette erreur :

Code:

---

1 2 3 4 5 6 7

MaClasse.cpp: In constructor 'Page::Page(byte)':   MaClasse.cpp:15:21: error: cannot convert 'Page::Page(byte)::__lambda0' to 'void (*)(boolean) {aka void (*)(bool)}' in assignment   btn1.surAppui = [this](boolean a) {chgtPage(a); };   ^

---

qui me dit qu'il ne peut pas convertir, mais pourquoi ?

Merci de votre aide.

Pierre

Il faut faire les deux modifications indiquées pour que ça marche :
- À l'endroit de l'appel, utiliser le lambda (ça, c'est bon, tu l'as fait)
- Quand tu déclares ta variable surAppui, lui donner comme type std::function<void(bool)>, et non plus void(*)(boolean) (il faut avoir inclus le header <functional> pour ça)

Citation:

---

Envoyé par JolyLoic

... (il faut avoir inclus le header <functional> pour ça)

---

j'ai donc ajouté à mon programme :

Code:

---

#include <functional>

---

et voilà la réponse :

Code:

---

fatal error: functional: No such file or directory

---

Apparemment, dans l'environnement "Arduino" dans lequel je travaille, ça ne doit pas exister :(

Il doit bien y avoir moyen d'y échapper ?

Cordialement.

Pierre

JolyLoic te parle de C++YY (C++11, C++14, C++17, et plus) Est-ce que ton compilateur est compatible? :mrgreen: (<- pourtant il semble l'être)

Sinon, prends ma réponse parce que c'est du C++03 et elle passe partout. Par contre comme l'a dit JolyLoic, les pointeurs de fonction membre c'est super limité parce que tu dois toujours l'utiliser avec un objet de la classe en question.

Et après soit trouve le moyen d'avoir un compilateur C++YY (et donc pouvoir coder des lambdas) soit essayes de faire la première solution avec les template de JolyLoic

@ChPr : Voici un lien sur comment utiliser les pointeurs vers membre de classe en C++03 :
http://cpp.developpez.com/cours/cpp/?page=page_10#LX-P

Citation:

---

Envoyé par foetus

JolyLoic te parle de C++YY (C++11, C++14, C++17, et plus) Est-ce que ton compilateur est compatible? :mrgreen: (<- pourtant il semble l'être) ...

---

Le compilateur est AVR-GCC.

Citation:

---

Envoyé par foetus

... Sinon, prends ma réponse parce que c'est du C++03 et elle passe partout. Par contre comme l'a dit JolyLoic, les pointeurs de fonction membre c'est super limité parce que tu dois toujours l'utiliser avec un objet de la classe en question.

---

Est-ce que le fait d'utiliser des enfants pose problème ?

Voici le code simplifié. Je n'arrive vraiment pas à trouver ce qu'il faut écrire à la ligne 21 :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

class Base { public : void (* surAppui)(boolean); // pointeur sur une fonction };   class Bouton : public Base { public : boolean appuye = false; Bouton(String nom); void select(byte x, byte y) { if (surAppui != NULL) surAppui(appuye); } };   class Page : public Base { public : void chgtPage(boolean); Bouton btn1; Page(byte p) : btn1("Marche") { void(Bouton::*btn1.surAppui)(boolean) = &Page::chgtPage; // Ça, ça ne se compile pas } };

---

et voici un petit exemple qui se compile sans problème :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class A { public: int fonction(int a); };   int A::fonction(int a) { return a * a; }   void setup() { // Ca, c'est le "main" de Arduino int (A::*ptr)(int) = &A::fonction; }

---

Merci de votre aide.

Pierre

Désolé pas trop de temps :oops: mais cela ne compile pas parce qu'un pointeur de fonction de la classe Base est différent de la classe Page

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

class Base { // Attribute protected:   void (Base::*surAppui) (bool); // pointeur sur une fonction };     class Bouton : public Base { public :   // Constructor Bouton(std::string nom) : appuye(false) {}   void select(unsigned char x, unsigned char y) { if (surAppui != NULL) { surAppui(appuye); } }     // Attribute private:   bool appuye; };     class Page : public Base { public :   // Constructor Page(unsigned char p) : btn1("Marche") { // surAppui = &Page::chgtPage; // ca ne se compile pas (Base::*) != (Page::*) surAppui1 = &Page::chgtPage; }   void chgtPage(bool);     // Attributes private:   void (Page::*surAppui1) (bool);   Bouton btn1; };

---

Citation:

---

Envoyé par foetus

Désolé pas trop de temps :oops: ...

---

Mais il ne faut pas être désolé, chacun prend son temps ;).

Citation:

---

Envoyé par foetus

... mais cela ne compile pas parce qu'un pointeur de fonction de la classe Base est différent de la classe Page ...

---

Mais alors, est-ce qu'à un pointeur de la classe Bouton (surAppui) peut être affectée une fonction (chgtPage) de la classe Page ?

Je n'ai pas saisi les changements de code que tu as apporté sur ces pointeurs.

Cordialement.

Pierre

Citation:

---

Envoyé par ChPr

Le compilateur est AVR-GCC.

---

Argh ! C'est un truc qu'il faut que tu précises quand tu poses des questions, car son C++ n'est pas standard. J'ai trouvé http://stackoverflow.com/questions/3...dard-c-library où ils réimplémentent un truc comme std::function pour cet environnement, ça peut valoir le coup de regarder, mais j'ai peur que ce soit un peu ardu pour quelqu'un qui commence...

Je te propose donc l'alternative suivante, qui évite les pointeurs de fonction : Tu définis une classe de base avec une fonction virtuelle virtual void execute(bool b) = 0, ta variable surAppui devient un pointeur sur ce type (de préférence un unique_ptr, si ton compilateur connait ça), et pour appeler une fonction, tu fais une classe qui dérive de cette classe de base et dans sa fonction execute appèle la fonction que tu veux appeler. Si celle-ci est une fonction membre, tu devras dans ta classe dérivée stocker une référence à l'objet sur lequel cette fonction doit être appelée.

Si tu as beaucoup de classes dérivées comme ça à créer, tu peux même faire une macro pour en faciliter l'écriture. On croirait être revenu au C++ des années 90 :)

Citation:

---

Envoyé par JolyLoic

... Je te propose donc l'alternative suivante, qui évite les pointeurs de fonction ...

---

Avant que de m'orienter vers de nouvelles (pour moi) techniques, j'aimerais être sûr que, avec le langage conventionnel, il n'est pas possible, comme je le demandais précédemment :

- affecter à un pointeur d'une classe B héritée d'une classe de base A une fonction d'une classe C aussi héritée de la classe de base A.

Cordialement.

Pierre

Bon, finalement, j'ai résolu mon problème de manière beaucoup plus simple en testant dans Page si une propriété d'un Bouton appartenant à Page avait changé.

Pour autant, cette histoire de pointeur sur une fonction membre est quelque chose qu'il faudra que j’approfondisse.

En attendant, je vous remercie tous pour le temps que vous avez bien voulu me consacrer.

Cordialement.

Pierre

Citation:

---

Envoyé par ChPr

Pour autant, cette histoire de pointeur sur une fonction membre est quelque chose qu'il faudra que j’approfondisse.

---

Tu as raison parce que tu confonds encore la déclaration et la définition, même s'il faut le dire la syntaxe n'est pas très jolie/ pataude.

Et tu n'as pas compris qu'un pointeur de fonction membre est lié à une classe.
Donc si une classe B hérite d'une classe A, ce sont 2 classes différentes (même s'il y a un lien d'héritage) et leurs pointeurs de fonction membre sont différents.

Et apprends à lire les erreurs du compilateur :mrgreen:, c'est assez explicite:
main.cpp:111:19: erreur: cannot convert ‘void (Page::*)(bool)’ to ‘void (Base::*)(bool)’ in assignment.

Et avec un typedef (voir ci-dessous):
main.cpp:109:19: erreur: cannot convert ‘void (Page::*)(bool)’ to ‘Base::BASE_FUNC_PTR {aka void (Base::*)(bool)}’ in assignment.


Et enfin, on peut alléger cette syntaxe avec un typedef:

Code:

---

1 2 3 4 5 6 7 8

class Base { // Attribute protected:   typedef void (Base::*BASE_FUNC_PTR) (bool);   BASE_FUNC_PTR surAppui; };

---

OK, merci "foetus".

Cordialement.

Pierre

Citation:

---

Envoyé par ChPr

Avant que de m'orienter vers de nouvelles (pour moi) techniques,

---

Ce que je te propose n'a rien de nouveau, il s'agit juste d'une fonction virtuelle, comme tu en utilises déjà...