problème avec les listes chaînées.

Bonjour à toutes et à tous,

Ce qui suit est un programme destiné à tourner les les micro-contrôleurs Arduino.

Je souhaite créer des composants visuels dont le type de base est "CompBase"

Au fur et à mesure que j'en crée, ils doivent s'inscrire dans une liste chaînée "PtrComp". Le but de cette inscription est que, pendant le fonctionnement du programme je scruterai cycliquement chacun d'eux pour savoir s'iles reçoivent un évènement particulier.
Cette liste chaînée est telle qu'à chaque nouvelle inscription, le nouvel élément est placé à la fin de la liste.

Tout semble fonctionner, mais ce n'est qu'une apparence. Si je fais une scrutation cyclique, les pointeurs semblent se mélanger les crayons et les valeurs retournées ne sont pas bonne.

Pour vérifier cela, je parcours une fois la liste (dans la fonction "setup()") : les résultats sont corrects. Puis pour m'assurer que c'est vrai, je recommence une deuxième, une troisième et une quatrième fois : tout est toujours correct.

Maintenant, je recopie ces instructions dans la fonction "loop()" qui va boucler à l'infini ce qui y figure. Et bien là, les mêmes instructions qui fonctionnaient dans la partie setup() ne fonctionne plus.

Dès le premier passage, la dernière donnée est fausse. A partir du deuxième passage, toutes les valeurs retournées sont fausses, mais restent constantes.

Je n'arrive pas à voir ou est le problème. Est-ce dans la fonction d'ajout d'un élément à la liste, est-ce à son appel, est-ce encore au listage de la liste ?

Voici le programme :

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
#include <UTFT.h> // bibliothèque de l'afficheur 
 
UTFT myGLCD(ITDB32S, 38, 39, 40, 41); // création d'une instance de l'afficheur
extern uint8_t SmallFont[];
 
int indComp = 0; // index du composant créé
 
class CompBase; // déclaration forward du type CompBase
 
struct PtrComp {
  CompBase *ptr; // liste chaînée de CompBase
  PtrComp *suiv; // pointeur sur le prochain élément de la liste
  PtrComp *ajoutComp(CompBase *pt) { // méthode d'ajout d'un élément chaîné
    PtrComp *nouvComp = new PtrComp;
    nouvComp->ptr = pt; // enregistrement du pointeur sur le composant créé
    nouvComp->suiv = NULL;
    suiv = nouvComp;
    return nouvComp;
  }
};
 
PtrComp *compDeb = new PtrComp; // pointeur sur le début de la liste
PtrComp *compCour; // pointeur d'élément de liste
 
class CompBase { // composant de base
public:
  CompBase() { // constructeur
    if (indComp == 0) { // pour l'enregitrement du premier composant, je n'utilise pas la fonction ajout, mais ...
      compDeb->ptr = this; // ... comme il est déjà créé, je rempli seulement les cases
      compDeb->suiv = NULL;
      compCour = compDeb;
    }
    else {
      compCour = compCour->ajoutComp(this); // inscription dans la liste chaînée dès le deuxième composant
    }
    indComp++; // incrémente l'indice d'inscription dans le tableau des composants
  }
  int xx; // variable de test du composant
};
 
/*void scruteComp() {
 compCour = compDeb;
 for (int i = 0; i < indComp; i++) {
 myGLCD.print(String(i)+"  "+String(compCour->ptr->xx), 50, 200+10*i);
 compCour = compCour->suiv;
 }
 }*/
 
void setup() {
 
  // tout ce qui suit dans cette fonction setup() done de bons résulatts
 
  myGLCD.InitLCD(PORTRAIT); // initialisation de l'afficheur
  myGLCD.clrScr();
  myGLCD.fillScr(VGA_WHITE);
  myGLCD.setFont(SmallFont);
  myGLCD.setColor(VGA_BLACK);
  myGLCD.setBackColor(VGA_WHITE);
 
  CompBase truc;  // création du premier composant
  CompBase machin; // création d'un deuxième
  CompBase bouton; 
  CompBase aff; 
  CompBase bidule;
 
  truc.xx = 11; // affectation d'une valeur à la variable xx du composant
  machin.xx = 22;
  bouton.xx = 33;
  aff.xx = 44;
  bidule.xx = 55;
 
  compCour = compDeb; //je mets mon pointeur au début de la liste
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compDeb->ptr)), 50, 10); // j'affiche, via la liste le contenu dexx puis l'adresse du composant 
  compCour = compCour->suiv; // je pass à l'élément suivant
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 20);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 30);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 40);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 50);
 
  compCour = compDeb;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compDeb->ptr)), 50, 80);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 90);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 100);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 110);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 120);
 
  compCour = compDeb;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compDeb->ptr)), 50, 150);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 160);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 170);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 180);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 190);
 
  compCour = compDeb;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compDeb->ptr)), 50, 220);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 230);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 240);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 250);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 260);
}
 
void loop() {
  // put your main code here, to run repeatedly:
  delay(2000);
  myGLCD.fillScr(VGA_WHITE);
 
  // le code qui suit est le même que celui de la fonction setup(), mais ça ne fonctionne plus
  *compCour = *compDeb;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compDeb->ptr)), 50, 10);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 20);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 30);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 40);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 50);
 
  compCour = compDeb;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compDeb->ptr)), 50, 80);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 90);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 100);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 110);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 120);
 
  compCour = compDeb;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compDeb->ptr)), 50, 150);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 160);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 170);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 180);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 190);
 
  compCour = compDeb;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compDeb->ptr)), 50, 220);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 230);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 240);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 250);
  compCour = compCour->suiv;
  myGLCD.print(String(compCour->ptr->xx)+"  "+String(long(compCour->ptr)), 50, 260);
 
}

Voilà, si vous avez un peu de temps à me consacrer et me dire où le problème peut exister ...

Cordialement.

Pierre

Bonjour,

il faudrait un peu relire ton code, à moins qu'il ne s'agisse que d'une coquille copié sur le forum (j'en doute)
Citation:
Code:

1 2 // le code qui suit est le même que celui de la fonction setup(), mais ça ne fonctionne plus *compCour = *compDeb;
Joli commentaire qui dit ce que c'est sensé faire, suivi d'une ligne qui n'a absolument rien à avoir avec ce qu'elle est sensée copiée;
Et qui n'a rien à voir niveau fonctionnement avec ce que fait l'original.
Si tu déférences un pointeur, tu as un objet, tu ne fais ni plus ni moins qu'une affectation à ce moment là, partant de là les résultats doivent être plutôt douteux, et même carrément crasher.

Merci Bousk pour cette réponse, mais c'est bien une coquille à la réécriture sur le forum.

Dans chacune des lignes suivantes :

Code:

myGLCD.print(String(compCour->ptr->xx)+" "+String(long(compDeb->ptr)), 50, 10); // j'affiche, via la liste le contenu de xx puis l'adresse du composant

aussi bien dans la partie setup() que le partie loop(), l'adresse du composant est la bonne, mais c'est la donnée xx qui n'est plus bonne dans la partie loop(). Comme si "quelque chose" les avait changées ?

Merci de votre aide.

Pierre

Bon, en fait, j'ai trouvé. C'est en me relisant pour la n.ième fois que je me suis aperçu que j'instanciais mes composants dans la section setup() et non dans la partie globale.

Désolé pour cette grossière erreur.

Cordialement.

Pierre