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

**ChPr** · 12/09/2013, 12h17

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 :

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

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

Langage C++

Mode arborescent

Discussions similaires

Partager

Partager