Discussion :

[Nicoclem]

Bonjour !

Je suis en train de créer des listes chainées en C++ (je sais que cela serait mieux en C, étant donnée que l'on peut utiliser le conteneur List en C++, mais c'est pour un travail) avec des templates et j'ai quelques difficultés depuis quelques jours avec le constructeur par copie de la liste.

Voici mon 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
 
#include<stdio.h>
#include<stdlib.h>
 
//Classe Maillon 
template <class T>
class Maillon
{
        public:
                T m_data;
                Maillon <T>* m_next;
 
                //Forme canonique de Coplien
                Maillon();
                Maillon(const Maillon <T>&);
                ~Maillon();
};
 
//Classe Liste
template <class T>
class Liste 
{
	        Maillon <T>* m_tete;
	        Maillon <T>* m_fin;
 
        public:
 
                //Forme canonique de Coplien
                Liste();
                Liste(const Liste<T>&);
                ~Liste();
};
 
#include "Liste.inl"

et ici le fichier Liste.inl dans lequel j'implémente les méthodes précédentes :

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
 
//Classe Maillon 
 
//Constructeur par défaut
template<class T>
Maillon<T>::Maillon():m_data(),m_next(NULL){}
 
//Constructeur par copie
template<class T>
Maillon<T>::Maillon(const Maillon<T>& leMaillon)
{
        m_data = leMaillon.m_data;
        m_next = leMaillon.m_next;
}
 
//Destructeur
template<class T>
Maillon<T>::~Maillon(){}
 
//Classe Liste
 
//Constructeur par défaut
template<class T> 
Liste<T>::Liste():m_tete(NULL),m_fin(NULL){}
 
//Constructeur normal
 
//Constructeur par copie
template<class T> 
Liste<T>::Liste(const Liste<T>& laListe):m_tete(NULL),m_fin(NULL)
{
        if (laListe.m_tete != NULL) //Si la liste n'est pas vide
        {
                //Copie du premier élément
                m_tete = new Maillon<T>(laListe.m_tete->m_data); 
 
                //Copie du dernier élément 
                m_fin = new Maillon<T>(laListe.m_fin->m_data);
 
                //Pointeur qui parcours la liste que l'on copie
                Maillon<T>* ptrParcours = laListe.m_tete; 
 
                //Pointeur qui parcours la liste que l'on construit
                Maillon<T>* ptrLocal = m_tete;
 
                while (ptrParcours != NULL)
                {
                        //On avance dans la liste "laListe"
                        ptrParcours = ptrParcours->m_next;
 
                         //On avance dans la liste locale
                        ptrLocal = ptrLocal->m_next; 
 
                        //Création d'un nouveau maillon
                        ptrLocal = new Maillon<T>(ptrParcours);
                }
        }         
}
 
 
template<class T>
Liste<T>::~Liste(){}

Le problème arrive avec le main.cc à cause du constructeur par copie :

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
 
#include "Liste.h"
 
#include <iostream>
using namespace std;
 
int main(int argc, char **argv)
{
        cout << "\nDEBUT PROGRAMME DE TEST\n" << endl;
 
        Liste <int> L1;
        Liste <int> L2(L1);
 
        cout << "SORTIE PROGRAMME TEST\n" << endl;
}

J'ai un peu de mal à voir ou se trouve mes erreurs. Si quelqu'un pouvait m'aider à trouver ce qui ne va pas je lui en serai très reconnaissant.

Merci d'avance !

[JolyLoic]

J'ai juste regardé rapidement, donc j'ai pu louper un truc.

J'ai l'impression que tu copies 2 fois le dernier maillon, ce qui fait que le dernier maillon connu par ta liste n'a aucun rapport avec le dernier maillon qui s'y trouve vraiment.

Tu devrais plutôt avoir en fin de boucle un truc genre :

Code :

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

m_fin = ptrLocal;

[Médinoc]

Ta classe Maillon n'a pas de constructeur prenant un T en paramètre, alors que tu l'appelles dans ton new.

De plus, je pense que tu devrais interdire la copie de Maillon (rendre son constructeur de copie privé).

[Nicoclem]

Ok merci d'avoir répondu je vais regarder cela en détail. Est ce que tu pourrais m'expliquer la nécessité d'interdire la copie du maillon ?

Merci !

[Médinoc]

Très simple: Tu ne doit pas copier un maillon car ça copierait le chaînage.
Et si tu fais un constructeur de copie qui ne copie pas le chaînage, autant ne pas en faire du tout puisqu'il n'y a que m_data à copier.