Discussion :

[ChPr]

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 :

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

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 :

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

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 :

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

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 :

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

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 :

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

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

[foetus]

Ton compilateur te dit explicitement ce qui ne va pas

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

En gros , 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).

[JolyLoic]

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 :

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

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

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 :

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

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"
  }
}

[ChPr]

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 :

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

btn1.surAppui = &chgtPage;

par

Code :

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

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

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

Code :

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

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

[JolyLoic]

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)

[ChPr]

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

j'ai donc ajouté à mon programme :

Code :

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

#include <functional>

et voilà la réponse :

Code :

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

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

[foetus]

JolyLoic te parle de C++YY (C++11, C++14, C++17, et plus) Est-ce que ton compilateur est compatible? (<- 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

[Pyramidev]

@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

[ChPr]

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

Le compilateur est AVR-GCC.

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

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

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

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

[foetus]

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

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
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;
};

[ChPr]

Désolé pas trop de temps ...

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

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

[JolyLoic]

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

[ChPr]

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

[ChPr]

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

[foetus]

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 , 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 :

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

1
2
3
4
5
6
7
8
class Base {
// Attribute
protected:
 
    typedef void (Base::*BASE_FUNC_PTR) (bool);
 
    BASE_FUNC_PTR surAppui;
};

[ChPr]

OK, merci "foetus".

Cordialement.

Pierre

[JolyLoic]

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