Bonjour à tous !

J'ai un petit travail à faire pour manipuler des listes chainées. Pour ce faire, je dispose de 2 classes, et j'ai obligation de redéfinir les opérateurs pour effectuer mes opérations.
Je suis deja bloqué sur mon premier opérateur que je teste : l'opérateur + qui est en fait la "concaténation" de 2 listes.

Lorsque je le teste, avec mes listes l1 et l2, l1 contenant 0 et l2 contenant 1, il devrait m'afficher 0 1 , or il ne m'affiche que 0 ! On dirait bien qu'il y a un problème que je ne parviens pas à identifier.

Voici mon code :

Fichier liste.h :
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
 
// Creer une liste d'objets de la classe T en completant
// l'interface suivante. Transformer ensuite la liste en
// liste generique (template)
//
 
// Classe maillon
class maillon {
      // Champs prives
      private:
        double data;
        maillon *suivant;
 
      // Forme canonique de Coplien
      public:
        maillon();
        maillon(const maillon&);
        maillon(double);
        ~maillon();
        maillon& operator=(const maillon&);
 
      // Autres methodes et operateurs
      // ...
      friend class liste;
};
 
// Classe liste
class liste {
      // Champs prives
      private:
        maillon *tete, *fin, *cour;
 
      // Forme canonique de Coplien
      public:
        liste();
        liste(const liste&);
        liste(const maillon&);
        ~liste();
        liste& operator=(const liste&);
 
      // Ajout de maillons
         liste& operator+ (double);
         liste& operator+ (const maillon&);
         liste& operator+ (const liste&);
 
      // Suppression de maillons
         liste& operator- (double); // suppression de la premiere occurence de T
         liste& operator- (int); // suppression du maillon d'indice donne
 
         void supprime_tete(); // supprime la tete de la liste
         void supprime(); // supprime tous les elements de la liste
 
      // Suppression 
 
      // Entrees-sorties
         void affiche () const; // Fonction constante qui ne peut pas modifier les champs de la classe
 
      // Autres methodes et operateurs
      friend class maillon;
};

Fichier liste.cc :
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
 
#include "liste.h"
#include <iostream>
 
//constructeur par défaut de maillon
maillon::maillon() {
  data = 0.0;
  suivant = NULL;
}
 
//constructeur par recopie de maillon
maillon::maillon(const maillon& m) {
  data = m.data;
  suivant = m.suivant;
}
 
//constructeur avec une valeur passée en paramètre
maillon::maillon(double val) {
  data = val;
  suivant = NULL;
}
 
//destructeur de maillon
maillon::~maillon() {
  if(suivant) delete suivant;
}
 
//redéfinition de l'opérateur = pour les maillons
maillon& maillon::operator=(const maillon& m) {
  data = m.data;
  suivant = m.suivant;
  return (*this);
}
 
 
//-----------------------------------------------------------------------
 
 
//constructeur par défaut de la classe liste
liste::liste() {
  tete = NULL;
  fin = NULL;
  cour = NULL;
}
 
//constructeur par recopie de la classe liste
liste::liste(const liste& l) {
  tete = NULL;
  fin = NULL;
  cour = NULL;
  *this+l;
}
 
//constructeur prenant un maillon en paramètre
liste::liste(const maillon& m) {
  tete = new maillon(m);
  fin = new maillon(m);
  cour = new maillon(m);
}
 
//destructeur de la classe liste
liste::~liste() {
  supprime();
}
 
//Redéfinition de l'opérateur = pour les listes
liste& liste::operator=(const liste& l) {
  supprime();
  return *this+l;
}
 
//Redéfinition de l'opérateur + pour les listes :
//Création puis ajout d'un maillon en fin de liste
liste& liste::operator+(double val) {
  maillon c;
  c.data = val;
  fin->suivant = new maillon(c);
}
 
//Redéfinition de l'opérateur + pour les listes :
//Ajout d'un maillon en fin de liste
liste& liste::operator+(const maillon& m) {
  fin->suivant=new maillon(m);
}
 
//Redéfinition de l'opérateur + pour les listes :
//concaténation de deux listes
liste& liste::operator+(const liste& l) {
  maillon *c = l.tete;
  while(c) {
    if(tete == NULL) tete=fin=cour=new maillon(*c);
    else {
      fin->suivant = new maillon(*c);
      fin = fin->suivant;
    }
    fin->suivant = NULL;
    c = c->suivant;
  }
  return *this;
}
 
//Méthode supprime de la classe liste :
void liste::supprime() {
  while(tete) {
    cour=tete->suivant;
    delete tete;
    tete=cour;
  }
}
 
 
void liste::affiche() const {
  maillon *c = tete;
  while(c != NULL) {
    std::cout << c->data << std::endl;
    c = c->suivant;
  }
}
 
 
 
//http://www.seasofcheese.net/~julien/enseignement/cplusplus/tp/tp2_corrige/
 
 
 
 
//méthode main pour tester le programme
int main(int argc, char **argv)
 
{
 
 
 
	std::cout << "PROGRAMME DE TEST" << std::endl;
 
 
 
	maillon m(0.0), m1(1.0),m2(2.0),m3(3.0),m4(4.0),m5(5.0);
        liste l(m);
        liste l2(m1);
        liste l3=l+l2;
 
        l3.affiche();
 
 
 
	std::cout << "SORTIE TEST" << std::endl;
 
}


Voici l'affichage :

PROGRAMME DE TEST
0
SORTIE TEST




Merci à vous !