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 !