Discussion :

[snyfir]

Bonjour, j'ai créé deux classes qui gère une liste chainé.
J'ai une méthode dans ma classe liste qui ajoute un maillon à ma liste.
Le problème est qu'il n'est pas d'accord que je mette l'argument de ma fonction en constante. Pourtant je ne modifie pas l'élément maillon. Comment faire pour qu'il accepte le const ?
Merci d'avance.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Liste& operator+(const Maillon &m) {    
    if (tete == NULL) {
        tete = &m;
    } else {
        fin->suiv = &m;
    }
    fin = &m;

    return *this;
}

[JulienDuSud]

le type de tete et de suiv, et de fin ?

[Lavock]

Soit tu passes tes membres tête, fin et fin::suiv en const ;
Soit, mais c'est pas clean DU TOUT, tu fais un const_cast<>...

Et bonjour à tous :p !

[snyfir]

le type de tete et de suiv, et de fin ?

J'ai oublié de préciser, tete, suiv et fin sont des pointeurs de Maillon

[JulienDuSud]

Tu récupères des références constantes vers Maillion dans ton opérateur+.

Normal que le comilateur ne te laisse pas assigner ces références vers des pointeurs qui ne garantissent pas que l'objet qu'ils pointent resteront constants.

Tes pointeurs doivent donc pointer non pas sur des Maillon mais sur des Maillon const.

Après, tout dépend de ce que tu veux faire, tu veux peut-être uniquement garder des copies des objets passés via l'opérateur +.

Dans ce cas, ceci doit faire l'affaire:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Liste& operator+(const Maillon &m) {    
    Maillon *n = new Maillon( m );
    if (tete == NULL) {
        tete = n;
    } else {
        fin->suiv = n;
    }
    fin = n;
 
    return *this;
}

Attention par contre à bien libérer la mémoire.

[Klaim]

JulienDuSud, tu n'utilises pas n dans ton exemple...

[Médinoc]

Attention à ne pas confondre operator+ avec operator+=.

Cette opération d'ajout est clairement un +=...

[JulienDuSud]

JulienDuSud, tu n'utilises pas n dans ton exemple...

Oui, = m devrait être = n

[koala01]

Salut,

Typiquement, je n'utiliserais pas l'opérateur + (ni même l'opérateur += conseillé par Médinoc, même si c'est moins mauvais)...

En effet, la sémantique que l'on retrouve dans une liste chainée est:

1. de pouvoir insérer un (ou des) objet n'importe où (que ce soit au début, entre deux éléments existants ou à la fin)
2. de pouvoir être triée

Il me semblerait donc opportun de prévoir des fonctions membres dont les noms représentent clairement ce genre de services, typiquement

1. ajouteDebut
2. ajouteFin
3. insere
4. tri

De plus, j'aurais "naturellement" tendance à estimer que, si on ajoute un élément unique, ce n'est pas un maillon qu'il faut passer en argument, mais un objet du type représenté dans la liste.

Si l'on transmet un maillon, l'idée serait en réalité de pouvoir en ajouter une succession, pouvant représenter plusieurs maillons successifs d'une chaine existante.

Au final, nous aurions donc des fonctions proches de

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
/*les versions des fonctions qui ajoutent un élément */
void Liste::ajouteDebut(Type const & t)
{
   /* je considère que Maillon dispose d'un constructeur prenant en
    * en argument un objet du type à maintenir dans la liste
    */
    Maillon * temp=new Maillon(t);
    temp->suivant=tete;
    tete = temp;
}
void Liste::insere(Maillon & before, Type const & t)
{
    Maillon *temp= new Maillon(t);
    temp->suiv = before->suiv;
    before->suiv=temp;
}
void Liste::ajouteFin(Type const & t)
{
    Maillon *temp = new Maillon(n);
    if(queue)
        queue->suiv=temp;
   queue= temp;
   if(!tete)
       tete= temp;
}
/* versions qui ajoutent une succession de maillons dont le premier
 * maillon inséré est first et le dernier maillon inséré est celui qui 
 * précède last
 */
void Liste::ajouteDebut(Maillon const & first, Maillon const & last)
{
   Maillon const & temp =first;
   while(temp!=last)
   {
       /* je considère que Maillon dispose de l'opérateur * qui permet
        * de récupérer la valeur
        */
       ajouteDebut( *temp);
       /* je considère que Maillon dispose de l'opérateur d'incrémentation
        * qui permet de passer au maillon suivant 
        */
       ++temp;
   }
}
void Liste::insere(Maillon & before, Maillon const & first, 
                   Maillon const & last)
{
   Maillon const & temp =first;
   while(temp!=last)
   {
       /* je considère que Maillon dispose de l'opérateur * qui permet
        * de récupérer la valeur
        */
       insere( before, *temp);
       ++temp;
       ++before;
   }
}
void Liste::ajouteFin(Maillon const & first, Maillon const & last)
{
   Maillon const & temp =first;
   while(temp!=last)
   {
       ajouteFin( *temp);
       ++temp;
   }
}