Discussion :

[ChPr]

Dans un précédent post je vous montrais la construction d'une liste chaînée pour enregistrer des composants. Je la reporte ici :

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

Cela fonctionne bien. Mais ce qui m’ennuie est que pour le premier élément, je n'utilise pas la méthode "ajout" et passe par un substitut lorsque indComp vaut "0"

J'ai modifié l'appel à la construction de la liste chaînée de la manière suivante : les modifications sont en italiques dans les codes ci-dessus et ci-après

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
int indComp = 0; // index du composant créé
 
class CompBase; // déclaration forward du type CompBase
 
struct PtrComp { // rien n'est changé dans cette structure
  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; // pointeur sur le début de la liste : il n'est plus créé ici
PtrComp *compCour; // pointeur d'élément de liste
 
class CompBase { // composant de base
public:
  CompBase() { // constructeur
    compCour = compCour->ajoutComp(this); // inscription dans la liste chaînée dès le premier composant
    if (indComp == 0)
      compDeb = compCour; // c'est à que je fixe la valeur de compDeb
    }
    indComp++; // incrémente l'indice d'inscription dans le tableau des composants
  }
  int xx; // variable de test du composant
};

Utilisant cette deuxième méthode, à la création du premier composant, un de ses paramètres n'est pas pris en compte. Je suppose que cela vient de la méthode d'enregistrement, mais je ne vois pas où.

Si quelque chose vous saute aux yeux.

Merci de votre aide.

Pierre

[AF_2.8]

Quand alloues-tu compDeb, et surtout compCour, car pour pouvoir faire

Code :

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

compCour = compCour->ajoutComp(this);

il faut que compCour ait été alloué au préalable.


PS : Question qui peut paraitre idiote, mais pourquoi ne pas utilisé les listes chainées de la STL ?

[ChPr]

Merci A.F_2.8 pour cette réponse.

Quand alloues-tu compDeb, et surtout compCour, car pour pouvoir faire

Code :

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

compCour = compCour->ajoutComp(this);

il faut que compCour ait été alloué au préalable. ...

compCour est alloué dans la méthode ajout en prenant la valeur de nouvComp

... PS : Question qui peut paraitre idiote, mais pourquoi ne pas utiliser les listes chainées de la STL ?

Je ne connais pas, je vais ce que c'est et si c'est compatible avec l'environnement Arduino.

Cordialement.

Pierre

[AF_2.8]

compCour n'est pas alloué, tu lui affectes un pointeur, il pointe donc sur des données existante, mais lorsque que tu l'utilises pour la première fois dans le constructeur, pour moi il n'a pas encore été alloué.

[r0d]

La STL est la bibliothèque standard du c++. Elle est généralement livrée avec le compilateur. Elle définit tout un tas de classes et fonctions qui sont utiles dans la plupart des programmes. Arduino propose sa propre bibliothèque, qui ne contient pas de liste chaînée, mais il existe des adaptations de la stl sur arduino . Mais ça a l'air un peu galère, et surtout trop lourd (en terme de taille de l'exécutable).

En revanche, du devrais faire l'effort de mieux nommer tes variables et fonctions. Ça a l'air de rien mais c'est réellement important. Par ex: CompBase -> BaseComposant, indComp -> component_index, etc. Le code compilé aura la même taille (si c'est ce qui te préoccupe), mais le code sera plus lisible, et surtout, ça te force à expliciter ce que tu es en train de programmer, et donc ça aide beaucoup à avoir une vision beaucoup plus claire du programme qu'on est en train d'écrire.

[Bousk]

Et tu te serais peut-être rendu compte que ce que fait ton "cas particulier" quand ça vaut 0 n'est vraiment pas loin (voire totalement identique ? c'est fatiguant, contre-productif et ça donne pas envie de lire ces noms.. et pi pourquoi la coloration syntaxique ne marche pas ?! ) à ce que fait ajouterComp..!

Enfin, en pratique c'est toujours mieux d'avoir une classe qui est clairement la tête de list et qu'on ne manipule que cette tête et non les éléments courants, de début etc...
>> Exercice typique des premières semaines de C en école.

Btw, quid de la libération de la liste ?

[ChPr]

La STL est la bibliothèque standard du c++.... mais il existe des adaptations de la stl sur arduino. Mais ça a l'air un peu galère, et surtout trop lourd (en terme de taille de l'exécutable). ...

Je vais voir de quoi il en retourne et si ce n'est pas trop lourd, je vais m'en servir, mais cela nécessite un apprentissage supplémentaire du C++ pour moi car pour l'instant, je suis vraiment un débutant dans ce langage.

... En revanche, du devrais faire l'effort de mieux nommer tes variables et fonctions. Ça a l'air de rien mais c'est réellement important. Par ex: CompBase -> BaseComposant, indComp -> component_index, etc. Le code compilé aura la même taille (si c'est ce qui te préoccupe), mais le code sera plus lisible, et surtout, ça te force à expliciter ce que tu es en train de programmer, et donc ça aide beaucoup à avoir une vision beaucoup plus claire du programme qu'on est en train d'écrire.

Je suis bien conscient que la taille du programme compilé n'a rien à voir avec la taille du nom des variables.

Je te suis dans ton raisonnement sur des noms de variable explicites. Pour autant, cela fait 30 ans que je programme en Pascal objet avec des noms qui sont, je le reconnais, des contractions pas très lisibles ... pour les autres. J'ai adopté cela car, pour moi, je préfère avoir des noms relativement courts (mais que je comprends) plutôt que d'avoir à lire des lignes interminables dues à des noms assez longs. D'autant plus qu'en C++ on ne bénéficie par de l'instruction "with" du Pascal (à manier avec circonspection) qui permet d'abréger les lignes de code.

Cordialement.

Pierre

[ChPr]

compCour n'est pas alloué, tu lui affectes un pointeur, il pointe donc sur des données existante, mais lorsque que tu l'utilises pour la première fois dans le constructeur, pour moi il n'a pas encore été alloué.

Tu as raison, dans la partie modifiée, j'ai initialisé compCour :

Code :

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

PtrComp *compCour = new PtrComp; // pointeur d'élément de liste

et cela fonctionne bien.

Merci beaucoup.

Pierre