Discussion :

[_Froggy_]

Bonjour,

J'ai 2 class "identique" et je souhaiterais pouvoir accéder à l'une ou l'autre via un pointer pour avoir un code générique

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
 
class Class1 {
 public :
  uint8_t Var1;
  uint8_t Var2[20];
 
 void Class1();
  bool Func1(); //fait une action a
  bool Func2(); //fait une action b
}
 
class Class2 {
 public :
  uint8_t Var1;
  uint8_t Var2[20];
 
  void Class2();  
  bool Func1();  //fait une action c
  bool Func2();  //fait une action d
}

Dans l'idée, j'aurais voulu faire comme suit mais cela ne peut pas fonctionner (ou alors je n'ai pas trouvé comment) :

Code :

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

1
2
3
 
Class1 test[0] = Class1();
Class2 test[1] = Class2();

Je me suis réorienté sur une class "contenaire" qui fait le job à la place :

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
 
class Class_global() {
 public:
  uint8_t Var_global_1;
  uint8_t Var_global_2[20];
  bool (Class1::*Func_global_1())();
 
  void Class_global() {
   Class1 toto = Class1();
   *Var_global_1 = &toto.Var1; //renvoit "invalid type argument of unary '*' (have 'uint8_t {aka unsigned char}')"
   *Var_global_2 = &toto.Var2; //warning: invalid conversion from 'uint8_t (*)[40] {aka unsigned char (*)[40]}' to 'uint8_t {aka unsigned char}'
   Func_global_1 = &toto.Func1; //renvoit "warning: ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say '&Class1::Func1' [-fpermissive]" 
 
 
  }
}

Normalement j'aurais du déclaré "uint8_t *Var_global_1"; néanmoins j'ai peur ensuite de faire des erreurs en oubliant d'appeler "&Var_global_1" plutôt que "Var_global_1". En faite je pensais que je pouvais modifier la valeur de l'address, mais à priori cela bloque et je ne comprends pas vraiment pourquoi.

Je ne sais pas si je suis très clair

En pratique, n'importe quelle autre solution me convient, l'objectif est de pouvoir accéder de manière indifférencié à Class1 ou Class2 de manière générique, mais je sèche un peu.

Merci d'avance,

[CGi]

En pratique, n'importe quelle autre solution me convient, l'objectif est de pouvoir accéder de manière indifférencié à Class1 ou Class2 de manière générique.

Peut-être en utilisant l'héritage ?

PS : Tu as du te tromper de forum ? Ici c'est le forum C, ton code ressemble à du C++, à moins que ce soit une sorte de C with class .

[_Froggy_]

Peut-être en utilisant l'héritage ?

PS : Tu as du te tromper de forum ? Ici c'est le forum C, ton code ressemble à du C++, à moins que ce soit une sorte de C with class .

C'est de l'"arduino", je ne sais pas si je peux le déplacer sur le forum C++. C'est plus une problématique de pointeur à mon sens que de class, mais pourquoi, je vais voir si je trouve un modérateur pour déplacer le message

J'ai regardé l'héritage, de ce que je comprends, mon problème reste entier à savoir un nom de variable unique pour 2 types.

[dalfab]

Je suppose que ton code est plutôt du C++, je fait une réponse en ce sens.

Suivant ton besoin exact, il existe plein de manière de faire ce que tu souhaites. Peut-être qu'un exemple concret d'utilisation nous permettrait de mieux te répondre.

La manière intuitive serait d'utiliser l'héritage, ça donne:

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
class Base {
 public :
   uint8_t Var1;
   uint8_t Var2[20];
 
   virtual bool Func1() = 0 ; // action à définir dans la dérivée
   virtual bool Func2() = 0;  // action à définir dans la dérivée
   ~Base() = default;
};
class Class1 : public Base {
 public :
   bool Func1() override; //fait une action a
   bool Func2() override; //fait une action b
};
class Class2 : public Base {
 public :
   bool Func1() override; //fait une action c
   bool Func2() override; //fait une action d
};

Tu peux alors utiliser la type Base pour représenter Class1 ou Class2. Attention ça n'a de sens que si la Base est utilisée via pointeur ou référence.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <array>
 
int  main() {
   Class1  class1;
   Class2  class2;
   std::array<Base*,2>  tabp{ &class1, &class2 };   // tableau de 2 pointeurs sur des Class1 ou des Class2
 
   for ( auto*  pclasse  :  tabp ) {   // va faire class1.a class2.c class1.b class2.d
      pclasse->Func1();
      pclasse->Func2();
   }
}

Mais il y d'autre manières sans l'héritage, on peut avoir une classe qui représente une Class1 ou une Class2, mais peut-être que ce code n'est pas possible sur Arduino:

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
#include <variant>
#include <array>
 
class Class1ouClass2 {
   std::variant<Class1,Class2>  cl1_ou_cl2;
public:
    Class1ouClass2( std::variant<Class1,Class2> classe ) : cl1_ou_cl2{std::move(classe)} {}
    // on devrait plutôt passer par la fonction-template std::visit(), mais l'opérateur conditionnel est plus lisible pour débuter
    bool  Func1() { return  (cl1_ou_cl2.index()==0) ? std::get<0>(cl1_ou_cl2).Func1() : std::get<1>(cl1_ou_cl2).Func1();  }
    bool  Func2() { return  (cl1_ou_cl2.index()==0) ? std::get<0>(cl1_ou_cl2).Func2() : std::get<1>(cl1_ou_cl2).Func2();  }
};
 
int  main() {
   Class1  class1;
   Class2  class2;
   std::array<Class1ouClass2,2>  tab{ Class1ouClass2{class1}, Class1ouClass2{class2} };   // tableau de 2 représentants de Class1 ou de Class2
 
   for ( auto&   classe  :  tab ) {   // va faire class1.a class2.c class1.b class2.d
      classe.Func1();
      classe.Func2();
   }
}

Il y aussi le proxy, ce que tu as essayé de faire en dernier y ressemble. C'est comme "Class1ouClass2" sauf que c'est un "ProxySurClass1ouClass2" qui au lieu de contenir une Class1 ou Class2, ne contient qu'une référence à un objet externe (Class1 ou Class2) et se fait passer pour lui.

On peut aussi utiliser la métaprogrammation avec un "duck typing" qui permet d'avoir un surcoût totalement nul. C'est plus complexe à mettre en place et peut-être impossible sur Arduino

[edgarjacobs]

Hello,

Il y a un forum dédié à arduino ici: https://www.developpez.net/forums/f2...arque/arduino/. Mais ton problème dans le cas présent me semble plus être un problème de c++.

[_Froggy_]

Je suppose que ton code est plutôt du C++, je fait une réponse en ce sens.

Suivant ton besoin exact, il existe plein de manière de faire ce que tu souhaites. Peut-être qu'un exemple concret d'utilisation nous permettrait de mieux te répondre.

C'est de "l'arduino" voir du STM32, c'est à priori du C/C++ mais j'ai l'impression qu'il y a quelques différences, j'ai eu des cas ou du code qui compile sous arduino, ne compile pas en C.
C'est vrai que je n'ai pas donné d'exemple, en l’occurrence j'ai plusieurs modules (par exemple des capteurs) qui ont les mêmes fonctionnalités de type "init()" "getData()". Actuellement, je parcours les modules avec des tests "if (module1) {module1.init(); module1.getData()}". Je voulais faire quelque chose de plus générique, ce qui me permettrait de rajouter autant de modules que je veux sans avoir à rajouter à chaque fois un test conditionnel.

Merci pour tes réponses, je vais me pencher sur la litterature.
Je pense que l'héritage sera effectivement le plus simple, j'aurais voulu conserver les class "exportables" (donc sans le public et utilisable comme tel) mais il y a un moment, c'est pénible.
J'ai un peu du mal à comprendre pourquoi une modification manuelle des adresses mémoires ne fonctionne pas. Sauf si j'ai zappé quelque chose, en ASM cela passerait sans problème, les appels de fonctions sont les mêmes et les retours aussi.

Hello,

Il y a un forum dédié à arduino ici: https://www.developpez.net/forums/f2...arque/arduino/. Mais ton problème dans le cas présent me semble plus être un problème de c++.

Exact, mais en l'occurence c'est plus un problème de conception que d'arduino

[dalfab]

C'est vrai que je n'ai pas donné d'exemple, en l’occurrence j'ai plusieurs modules (par exemple des capteurs) qui ont les mêmes fonctionnalités de type "init()" "getData()". Actuellement, je parcours les modules avec des tests "if (module1) {module1.init(); module1.getData()}". Je voulais faire quelque chose de plus générique, ce qui me permettrait de rajouter autant de modules que je veux sans avoir à rajouter à chaque fois un test conditionnel.

L'héritage est fait pour ça.

Je pense que l'héritage sera effectivement le plus simple, j'aurais voulu conserver les class "exportables" (donc sans le public et utilisable comme tel) mais il y a un moment, c'est pénible.

Je ne comprends pas en quoi le public est gênant?? Ni ce que tu entends par "exportable"? ni la pénibilité!

J'ai un peu du mal à comprendre pourquoi une modification manuelle des adresses mémoires ne fonctionne pas. Sauf si j'ai zappé quelque chose, en ASM cela passerait sans problème, les appels de fonctions sont les mêmes et les retours aussi.

Je connais les assembleurs, le C et le C++. Je ne vois pas en quoi ils auraient un comportement différent pour les adresses. Une adresse, c'est par définition immuable, et c'est référençable; la seule différence que je vois est:
- en assembleur, une adresse est anonyme (donc complexe de suivre ce qui est pointé)
- en C, une adresse est typée. On connait le type qui est pointé.
- en C++, on a en juste en plus du typage du C, la notion de vie de l'objet.
Peut-être souhaite-tu avoir un pointeur qui changerait de valeur pour pointer sur un autre type de donnée?
En C, ça serait un pointeur void. Mais ça donne un code ingérable.
En C++, on a d'autres possibilités (l'héritage permet cela à condition que les objets aient les même interfaces, ce qui semble être le cas!), on a aussi la notion de pointeur membre. Ca correspond à gérer un offset ajustable dans une famille d'objets. Ca permet plutôt de changer de fonction au sein d'un même objet, ou entre hiérarchie (au sens d'héritage) d'objets.

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
class Base {
    void  fct1();
    void  fct2();
    void Base::*pt_mb_fct = &Base::fct1;
 public:
    void  dorenavant_utiliser( int i ) {
        switch ( i ) {
            case 1: pt_mb_fct = &Base::fct1; break;
            case 2: pt_mb_fct = &Base::fct2; break;
        }
    }
    void  appeler_fonction_convenue() { (this->*pt_mb_fct)(); }
};
 
int  main() {
    Base  class;
    class.dorenavant_utiliser( 2 );
    class.appeler_fonction_convenue();  // va appeler la fct2(), donc ici l'appelant demande une fonctionnalité sans avoir
    // à explicitement retrouver une fonction, et en cas d'héritage elle pourrait être dans une sous hiérarchie (donc Class1 ou Class2).
}

[_Froggy_]

Je ne comprends pas en quoi le public est gênant?? Ni ce que tu entends par "exportable"? ni la pénibilité!

J'ai développer chaque module pour qu'il soit "indépendant" et donc réutilisable sur d'autres projets. Si j'inclue l'option d'héritage, les modules sont moins indépendants. C'est plus des réflexions personnelles quand j'ai écrit le message
La pénibilité c'est de garder justement un code le plus réutilisable possible, pouvant prendre en compte des caractéristiques (ici l'exportation pour d'autres projets) qui au final ne me serviront peut etre jamais et rend le développement plus ... pénible.

Dit autrement, la lecture d'un capteur de temperature via protocol I2C dans ma boucle principale pourrait être :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
main () {
 
 while(true) {
 
 initialisation_I2C();
 envoi_commande_I2C(capteur_température);
 lecture_trame_I2C(capteur_température);
 desinit_I2C();  
 }
}

qui devient (c'est un peu simpliste ici, la class n'a aucun d'intérêt) :

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
 
Class capteur_temperature {
 uint16_t get_value() {
  initialisation_I2C();
  envoi_commande_I2C(capteur_température);
  lecture_trame_I2C(capteur_température);
  desinit_I2C();  
 }
}
 
main () {
Class temp capteur_temperature;
uint16_t temperature;
 while(true) {
  temperature = temp.get_value();
}

Ensuite, je stock ma class dans un fichier et je peux l'inclure directement dans d'autres projets. Si j'ai l'option d'héritage, il faut également que j'inclue la seconde class, ce qui peut etre moins compréhensible. C'est vraiment du détail et pour le coup c'est à mon sens plus lié à comment le compilateur arduino gère les sources et certain défaut de conception que j'ai hérité de ce fonctionnement.

Peut-être souhaite-tu avoir un pointeur qui changerait de valeur pour pointer sur un autre type de donnée?

Les données restent les mêmes. Pour les fonctions cela compilent (mais je n'ai pas testé) quand je modifie les pointeurs comme tu le fais. Pour les variables, par contre, cela ne compile pas.

En faite, je pourrais faire cette version mais j'aurais voulu garder quelque chose de plus "joli" et moins consommateur de mémoire :

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
48
49
50
51
52
53
54
55
56
57
58
59
60
[class Class1 {
 public :
  uint8_t Var1;
  uint8_t Var2[20];
 
 void Class1();
  bool Func1(); //fait une action a
  bool Func2(); //fait une action b
}
 
class Class2 {
 public :
  uint8_t Var1;
  uint8_t Var2[20];
 
  void Class2();  
  bool Func1();  //fait une action c
  bool Func2();  //fait une action d
}
 
class Class_global() {
 public:
  uint8_t numero_Class = 0;
  Class1 Class1_Global = Class1();
  Class2 Class2_Global = Class2();
 
  void Class_global(uint8_t num) {
    numero_Class = num;
  }
 
  bool Func1() {
    if (numero_class == 1)
     return Class1_Global.Func1();
    if (numero_class == 2)
     return Class1_Global.Func2();
  }
 
  bool Func2() {
    if (numero_class == 1)
     return Class1_Global.Func2();
    if (numero_class == 2)
     return Class1_Global.Func2();
  }
 
  uint8_t get_Var1() {
    if (numero_class == 1)
     return Class1_Global.Var1;
    if (numero_class == 2)
     return Class1_Global.Var2;
  }
 
}
 
main{
  Class_global global[2];
  global[0] = new Class_global(1);
  global[1] = new Class_global(2);
 
  //reste du code
}

Je vais regarder pour les pointeur membre, à la limite pour les fonctions cela passe, c'est plus pour les variables que cela ne passe pas.
Merci en tout cas du temps consacré

[fred1599]

Bonjour,

Je ne suis pas un spécialiste du C++ loin de là, mais je connais la POO, je vais essayer d'aider selon mes capacités sur ce critère.

Dans l'idée, j'aurais voulu faire comme suit mais cela ne peut pas fonctionner (ou alors je n'ai pas trouvé comment)

Code :

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

1
2
3
 
Class1 test[0] = Class1();
Class2 test[1] = Class2();

Dans l'idée, tu ne peux ajouter dans test que des objets de même type, ce qui inclus la création d'une classe de base (une interface peut-être, je la nomme Base dans mon code) avec ses méthodes communes, et qui permettront de créer test.

Code :

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

std::vector<std::unique_ptr<Base>> test;

puis d'ajouter tes instances de Class1 et Class2

Code :

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

1
2
3
 
test.push_back(std::make_unique<Class1>());
test.push_back(std::make_unique<Class2>());

Pour l'utilisation des méthodes communes

Code :

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

1
2
3
4
 
for (const auto& obj : test) {
    obj->doSomething();
}

Niveau syntaxe je ne suis pas sûr, mais sur le principe, j'espère avoir été suffisamment clair...

[Bousk]

Soit héritage parce que si tes 2 classes ont les mêmes interfaces, elles sont potentiellement logiquement liées ?
Soit des fonctions templates pour les gérer.

[fred1599]

Soit héritage parce que si tes 2 classes ont les mêmes interfaces, elles sont potentiellement logiquement liées ?

C'est une manière de concevoir, sur le principe SOLID, la liaison entre classes peut différer (Interface Segregation) en créant plusieurs interfaces distinctes.
On pourrait par exemple créer 2 interfaces distinctes héritant de l'interface Base.

[_Froggy_]

Merci des réponses,
Il faut maintenant que je mette cela en pratique