Discussion :

[Nicodemus]

Bonjour,

J'ai un petit problème de conception concernant un constructeur de copie. Pour ce type de constructeur, l'objet est toujours passé en const... or avec la façon dont j'ai procédé, je suis obligé de le modifier pour le copier .

Je m'explique, j'ai une classe Liste qui comporte des opérations comme ValeurCourante(), Suivant(), Précédent()..etc...
Donc dans le constructeur par copie j'aurais voulu faire un truc du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Liste::Liste(const& pListe)
{
    pListe.FixerTete(); // position courante = la tête de la liste
    int i=0;
    int longueur = pListe.Longueur();
 
    //on parcours la liste passée en paramètre et on insère dans la liste actuelle les éléments un par un
    while ( i <= longueur )
    {
        Inserer(pListe.ValeurCourante());
        pListe.Suivant();
        i++;
    } 
}

Le problème est que les opération Suivant() et FixerTete() modifient l'objet donc ne respectent pas le const.
En gros... je me suis très mal débrouillé . Une idée pour me sortir de là ?

[Luc Hermitte]

Tu ferais mieux de différencier l'itérateur et la liste. Tu vas avoir un joli truc non réentrant sinon.

Autrement, je vois deux options pour corriger aveuglément (i.e. sans améliorer le design bancal) le problème -> déclarer mutable ton index interne (pas terrible), ou manipuler directement et à la main les attributs de ta liste d'origine (bourrin, peu maintenable).

[Nicodemus]

effectivement c'est pas la joie :-(
En fait j'implémente une classe liste dans le but de gérer une file de priorité min, donc une structure qui reconnait les opérations inserer, minimum, extraire_minimum et aussi diminuer_cle. Je pourrais tres bien utiliser la STL, mais le sujet impose un peu qu'on implémente les structures nous même (apres j'aurais droit aux ABR et tas binomiaux ).

Cmment je pourrais procéder alors ? ne pas utiliser des méthodes comme suivant et précédent et donc ne pas avoir de pointeur sur le noeud courant dans la liste ?

[Luc Hermitte]

Sépare les notions de listes, noeuds et itérateurs.

Typiquement l'interface vers laquelle tu pourrais t'orienter est celle présentée dans le GoF -- les itérateurs disposent des opérations Next() et First() (rewind), CurrentItem(), isDone().

Le truc est que le parcours n'est pas le rôle de la liste. Son rôle est de contenir, et de pouvoir être parcourrue (par un objet dont c'est le seul rôle)

Tu auras toutes fois besoin du type : Liste::Iterateur_const qui pointera vers une liste const et un noeud const, et renverra un item const.
Avec des templates, on peut arriver à ne définir qu'une seule classe itérateur, et en dériver les deux typedef. Voir p.ex. ce qui est fait dans les diverses implémentations de std::list.

[JolyLoic]

Je ne sais pas trop ce qu'est une classe de priotité min, mais j'ai l'impression que pour inserer, minimum et extraire_minimum, tu n'as pas besoin de notion d'élément courant.

Si en plus tu veux permettre de parcourir la liste (peut-être pour diminuer_clef dont je ne comprend pas le sens), plutôt que de mettre une notion d'élément courant dans la liste, tu lui donne une fonction begin et end qui retournent un itérateur. Cet itérateur peut lui naviguer dans la liste.

Avantages :
- Pas de problèmes pour implémenter la copie
- Possibilité d'avoir plusieurs itérations en parallèle
- Possibilité de réutiliser quelques algorithmes de la STL, selon le type d'opérateur