Accès indirect aux éléments d'une classe

Version imprimable

07/09/2013, 19h37
ChPr

Accès indirect aux éléments d'une classe
Bonjour à toutes et à tous,

A partir d'une classe C :
Code:

1 2 3 4 5 class C { public: int XX; void fct(int zz); };
je crée plusieurs instances c1, cA, c23, ...
Code:

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:

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

Hello,

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

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

07/09/2013, 20h33
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

Ha, c'est dommage.

L'utilisation reste proche/identique

Code:

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

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

NOTA :

Code:

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

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

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

Citation:

Envoyé par Iradrille

...

Code:

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

07/09/2013, 22h47
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.
07/09/2013, 22h56
ChPr

Citation:

Envoyé par Bousk

... 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
07/09/2013, 23h02
Bousk

Citation:

Envoyé par ChPr

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

Quel syntaxe essayes-tu qui plante le compilo ?

tab[i]->fct(); est totalement valide.
07/09/2013, 23h46
ChPr

Citation:

Envoyé par Bousk

... tab[i]->fct(); est totalement valide.

C'est vrai, iln'y a pas à rajouter de parenthèses ni d'étoile à condition de supprimer la ligne :

Code:

explicit C(int xx): XX(xx) { }

??

Cordialement.

Pierre

Pour une classe telle que :
Code:

1 2 3 4 5 6 7 8 9 class Truc { public: int xx; int fct(int yy); }; int Truc::fct(int yy) { return yy*yy; }
les deux formes suivantes d'appel de la classe Truc passent à la compilation :

Code:

Truc *ptrs[10];

et

Code:

Truc ptrs[10];

Pour autant, à l'exécution les résultats sont les suivants :

pour la première forme :
Code:

1 2 3 4 5 6 7 8 9 10 11 bidule.xx = -99; ptrs[0] = &bidule; b = (*ptrs[0]).xx; // b recueille bien la valeur -99 truc.xx = 55; ptrs[1] = &truc; b = (*ptrs[1]).xx; // b recueille bien la valeur 55 b = (*ptrs[1]).fct(25); // b recueille bien le résulta de la fonction : 625 (*ptrs[1]).xx = 100; // la valeur 100 est bien transmise à la variable xx de truc
pour la deuxième forme :
Code:

1 2 3 4 5 6 7 8 9 10 11 bidule.xx = -99; ptrs[0] = bidule; b = ptrs[0].xx; // b recueille bien la valeur -99 truc.xx = 55; ptrs[1] = truc; b = ptrs[1]).xx; // b recueille bien la valeur 55 b = ptrs[1].fct(25); // b recueille bien le résulta de la fonction : 625 ptrs[1].xx = 100; // la valeur 100 n'est pas transmise à la variable xx de truc
Voilà, dans cette deuxième forme, l'assignation d'une valeur à la variable via ptrs ne fonctionne pas ???

Cordialement.

Pierre

08/09/2013, 12h58
Iradrille

Pour la deuxième forme, ton tableau contient des copies de tes objets, l'objet dans le tableau est modifié, mais pas "truc".
Alors que la première forme contient des pointeurs (= l'adresse mémoire de tes objets).

Pour la ligne

Code:

explicit C(int xx): XX(xx) { }

C'est un oubli de ma part, pour créer un tableau, il faut un constructeur par défaut. C'est à dire que tu dois pouvoir créer des "C" sans leur fournir de paramètre. (Ou fournir les paramètres requis à la création des objets contenus dans le tableau).
08/09/2013, 16h44
ChPr

Je te remercie beaucoup Iradrille pour ces précisions.

Cordialement.

Pierre