Discussion :

[ChPr]

Bonjour à toutes et à tous,

A partir d'une classe C :

Code :

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

1
2
3
4
5
class C {
public:
  int XX;
  void fct(int zz);
};

je crée plusieurs instances c1, cA, c23, ...

Code :

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

1
2
3
4
C c1;
C cA;
C c23;
...

Je souhaite pouvoir accéder aux variables et méthodes de chacune des instances, mais sans passer le nom des instances.

Par exemple, j'ai créé un tableau de ??? qui "pointe" sur chacune des instances. Comment à partir de chaque élément du tableau accéder aux variables et méthodes de chacune des instances.

ce que je souhaite faire est par exemple :

Code :

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

1
2
3
4
5
6
type tableau[10]; //mettons que j'ai dix instances différentes de ma classe C
int yy;
for (int i = 0; i < 10; i++) {
  yy = tbl[i].xx;
  tbl[i].ftc(yy);
}

Le code ci-dessus étant "symbolique", quel doit être le type de mon tableau et quelle est la syntaxe à utiliser pour accéder à chacun des éléments ?

Merci de votre aide.

Pierre

[Iradrille]

Hello,

ton code symbolique est correct. On préfère cependant les std::vector au tableaux nus en C++

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
class C {
public:
  explicit C(int xx): XX(xx) { }
  int XX;
  void fct(int zz);
};
 
std::vector<C> tab; // un tableau de C
tab.push_back(C(2)); // ajout d'un C au tableau
tab.push_back(C(42)); // un 2eme
 
// via indices
for(int i=0; i<tab.size(); ++i) {
  std::cout << tab[i].XX << std::endl; // tab[i] est un élément du tableau, et est donc de type C
  tab[i].fct(0);
}
 
// ou via range loop
for(auto& elt: tab) {
  std::cout << elt.XX << std::endl; // elt est un élément du tableau, et est donc de type C
  elt.fct(0);
}
 
//ou via itérateurs
for(std::vector<C>::iterator it=tab.begin(); it!=tab.end(); ++it) {
  std::cout << (*it).XX << std::endl; // it est un itérator, *it est un élément du tableau, et est donc de type C
  (*it).fct(0);
}
 
// ou via std::for_each + foncteur
struct Foo {
  void operator()(C& c) {
    std::cout << c.XX << std::endl;
    c.fct(0);
  }
};
std::for_each(tab, Foo());
 
// ou via std::for_each + lambda
std::for_each(tab, [](C& c) {
  std::cout << c.XX << std::endl;
  c.fct(0);
});

[ChPr]

Merci beaucoup Iradrille pour ces solutions.

Malheureusement, je développe pour Arduino qui ne gère pas les std::vector.

Si vous aviez une solution à base de tableau ...

Merci de votre aide.

Pierre

[Iradrille]

Ha, c'est dommage.

L'utilisation reste proche/identique

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 C {
public:
  explicit C(int xx): XX(xx) { }
  int XX;
  void fct(int zz);
};
 
C tab[5]; // un tableau (alloué sur la pile, la taille doit être connue à la compilation)
C *tab2 = new C[5]; // alloué sur le tas, la taille peut ne pas être connue à la compilation
delete[] tab2; // ne pas oublier de supprimer ton tableau après utilisation (pas de smart pointers non plus je suppose)
 
// l'utilisation est identique aux vectors
for(int i=0; i<5; ++i) { // un tableau nu ne connait pas sa taille, tu dois donc la stocker quelques part
  std::cout << tab[i].XX << std::endl;
  tab[i].fct(0);
}

[ChPr]

Voici les modifs que j'ai dû faire pour que ce code compile :

...

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 C {
public:
  explicit C(int xx): XX(xx) { }
  int XX;
  void fct(int zz);
};
 
C *tab[5]; // Ajout d'une étoile devant tab
//C *tab2 = new C[5]; // je n'ai pas réussi à faire compiler cette variable
//delete[] tab2; // 
 
// l'utilisation est identique aux vectors
for(int i=0; i<5; ++i) { // un tableau nu ne connait pas sa taille, tu dois donc la stocker quelques part
//  std::cout << tab[i].XX << std::endl; // pas de std:: dans Arduino -> myGLCD
  (*tab[i]).fct(0); //ajout de parenthèses et d'une étoile devant tab
}

On revient pratiquement à ce que j'ai trouvé au petit bonheur la chance ???

Cordialement.

Pierre

[ChPr]

J'ai trouvé une solution, je l'avoue, par le plus grand des hasard. La voici :

NOTA :

Code :

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

1
2
3
 
UTFT myGLCD; // est une classe d'affichage propre aux modules Arduino
myGLCD.print(String mon_texte, int posX, int posY);

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
#include <UTFT.h>
 
UTFT myGLCD(ITDB32S, 38, 39, 40, 41);
extern uint8_t SmallFont[];
 
class Truc { // ma classe
public:
  int xx;
  int fct(int yy);
};
 
int Truc::fct(int yy) { // la fonction fct qui retourne le carré du paramètre
  return yy*yy;
}
 
Truc truc; // une instance de Truc
Truc *ptr = &truc; // un pointeur sur truc
Truc *ptrs[10]; // un tableau de 10 pointeurs
 
Truc bidule; // une deuxième instance de Truc
 
void setup() {
  // put your setup code here, to run once:
  myGLCD.InitLCD(PORTRAIT); // initialisation de l'afficheur
  myGLCD.clrScr();
  myGLCD.fillScr(VGA_WHITE);
  myGLCD.setFont(SmallFont);
  myGLCD.setColor(VGA_BLACK);
  myGLCD.setBackColor(VGA_WHITE);
 
  truc.xx = 55; // je donne une valeur à truc.xx
  myGLCD.print(String(truc.xx), CENTER, 20); // je l'affiche -> OK
  int b = 0;
  b = (*ptr).xx; // transfert de la valeur truc.xx dans b via le pointeur ptr
  myGLCD.print(String(b), CENTER, 30); // je l'affiche -> OK
  myGLCD.print(String((*ptr).fct(33)), CENTER, 40); // j'active la fonction et j'affiche le résultat -> OK
 
  bidule.xx = -99; // je donne une valeur à bidule.xx
 
  ptrs[0] = &bidule; //le premier élément du tableau pointe sur l'instance bidule
// NOTEZ : il n'y a plus d'étoile devant ptrs pour que cela fonctionne ???
  b = 0;
  b = (*ptrs[0]).xx+10; // transfert dans b
  myGLCD.print(String(b), CENTER, 50); // affichage -> OK
 
  ptrs[1] = &truc; // même chose avec le deuxième élément du tableau
  b = 0;
  b = (*ptrs[1]).xx-20;
  myGLCD.print(String(b), CENTER, 60); // ça marche toujours
 
  (*ptrs[1]).xx = 100; //inversement, je transfert dans l'instance truc la valeur 100
  myGLCD.print(String(truc.xx), CENTER, 70); // je l'affiche -> OK
 
}
 
void loop() {
  // put your main code here, to run repeatedly: 
 
}

Voilà, tout fonctionne comme je le souhaite. Mais, je l'avoue encore une fois, je n'ai rien compris à ce que j'ai fait :

• mise entre parenthèses de *ptr et *ptrs[i] ???
• pas d'étoile de vant le pointeur quand c'est un élément de tableau ???

Si vous pouviez me donner un début d'explication.

Merci de votre aide.

Pierre

[Bousk]

Bonsoir,

rien de vraiment difficile, peut-être faudrait-il replonger dans les cours de syntaxe du langage. Il ne s'agit ici que de syntaxes.

Concernant les parenthésages ou non, c'est principalement pour forcer l'ordre des opérations, sinon elles sont executées selon leur precedence, pas toujours évident à contrôler.

Enfin dans certains cas c'est pour déférencer le pointeur, ce qui n'a aucun intérêt ici. Accéder à un membre par . ou -> est strictement identique.


Si tu veux juste regrouper des objets existants dans un même tableau c'est effectivement une solution simple et possible.

[ChPr]

... Concernant les parenthésages ou non, c'est principalement pour forcer l'ordre des opérations, sinon elles sont executées selon leur precedence, pas toujours évident à contrôler.

Enfin dans certains cas c'est pour déférencer le pointeur, ce qui n'a aucun intérêt ici. Accéder à un membre par . ou -> est strictement identique. ...

Si je change d'un iota le code que je vous montre, cela ne se compile plus !! Donc, dans mon cas (Arduino), les parenthèses et les "." au lieu de "->" s'avèrent obligatoires.

Je n'ai pas exploré toutes les possibilités de syntaxe.

Cordialement.

Pierre