Discussion :

[bertry]

Boujours à tous,

Après l'aide à la résolution du problème dans la discussion : "nested class dans un class template", j'ai voulu compléter ma classe "LSC" (liste simplement chainée) avec son contructeur de recopie et son opérateur d'affectation. C'est là qu'est l'os : Je ne comprend pas d'ou vient l'erreur de compilation!
J'explique : La première fonction ( le constructeur de recopie ) est compilée sans problème... mais la deuxième ( l'opérateur d'affectation ) plante à la ligne indiquée en remarque. Mais pourquoi l'une passe et pas l'autre? Alors que les deux sont presque identiques!

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
template <class T> LSC<T>::LSC ( const LSC<T>& liste )
{
	debut = NULL;
	fin = NULL;
	size = 0;
 
	LSC<T>::iterator it;
	for ( int i = liste.size; i > 0; i-- )
	{
		it = liste.begin();
		for ( int j = 0; j < i; j++ )
			it++;
		this->pop_front( it->objet );
	}
}
 
template <class T> LSC<T>& LSC<T>::operator = ( const LSC<T>& liste ) //L143
{                                                                     //L144
	if ( this != &liste )                                         //L145
	{                                                             //L146
		debut = NULL;                                         //L147
		fin = NULL;                                           //L148
		size = 0;                                             //L149
                                                                      //L150
		LSC<T>::iterator it;                                  //L151
		for ( int i = liste.size; i > 0; i-- )                //L152
		{                                                     //L153
			it = liste.begin(); // L154 : ça plante ici en compilation!
			for ( int j = 0; j < i; j++ )
				it++;
			this->pop_front( it->objet );
		}
	}
 
	return *this;
}

Message d'erreur :

------ Début de la génération*: Projet*: Liste, Configuration*: Debug Win32 ------
Compilation en cours...
liste.cpp
d:\visual studio 2010\projects\liste\liste\lsc.h(154) : error C2662: 'LSC<T>::begin'*: impossible de convertir un pointeur 'this' de 'const LSC<T>' en 'LSC<T> &'
with
[
T=int
]
La conversion perd les qualificateurs
d:\visual studio 2010\projects\liste\liste\lsc.h(144)*: lors de la compilation de la fonction membre '<Inconnu>' de la classe <Inconnu>
d:\visual studio 2010\projects\liste\liste\liste.cpp(10)*: voir la référence à l'instanciation de la classe modèle 'LSC<T>' en cours de compilation
with
[
T=int
]
d:\visual studio 2010\projects\liste\liste\lsc.h(157) : error C2819: le type 'LSC<T>::iterator' n'a pas d'opérateur 'operator ->' de membre surchargé
with
[
T=int
]
d:\visual studio 2010\projects\liste\liste\lsc.h(22)*: voir la déclaration de 'LSC<T>::iterator'
with
[
T=int
]
souhaitez-vous utiliser '.' à la place*?
d:\visual studio 2010\projects\liste\liste\lsc.h(157) : error C2232: '->LSC<T>::iterator::objet'*: opérande gauche avec type 'class', utilisez '.'
with
[
T=int
]
d:\visual studio 2010\projects\liste\liste\lsc.h(157) : error C2660: 'LSC<T>::pop_front'*: la fonction ne prend pas 1 arguments
with
[
T=int
]
Le journal de génération a été enregistré à l'emplacement "file://d:\visual studio 2010\Projects\Liste\Liste\Debug\BuildLog.htm"
Liste - 4 erreur(s), 0 avertissement(s)
========== Génération*: 0 a réussi, 1 a échoué, 0 mis à jour, 0 a été ignoré ==========

Pour mémoire voici la déclaration de ma classe LSC :

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
template <class T> class LSC	// Liste Simplement Chainée
{
private:
	struct noeud {
		T* objet;
		noeud* suivant; };
	noeud* debut;		// Pointeur sur le premier noeud
	noeud* fin;			// Pointeur sur le dernier noeud
	unsigned int size;	//Taille de la liste
 
public:
	class iterator
	{
	private:
		noeud* noeudPointe;
		T* objet;
	public:
		iterator ();
		iterator ( noeud*, T* );
 
		iterator& operator = ( iterator& );
		iterator& operator ++ ( int );	// ++ postfixé!
		T operator * ();
 
		bool operator == ( iterator& );
		bool operator != ( iterator& );
	};
	LSC ();	// Constructeur usuel
	~LSC ();// Destructeur
	LSC ( const LSC<T>& );	// Constructeur de recopie
	LSC<T>& operator = ( const LSC<T>& ); //affectation
 
	void push_front ( const T& );
	void pop_front ();
 
	iterator begin ();
	iterator end ();
 
	template <class T> friend std::ostream& operator << ( std::ostream&, LSC<T>& );
};

Merci de votre aide...

[ram-0000]

Code :

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

1
2
3
4
5
6
7
8
9
iterator begin ();
 
...
 
template <class T> LSC<T>& LSC<T>::operator = ( const LSC<T>& liste )
 
...
 
it = liste.begin();

Ta fonction begin() telle que déclarée dans le .h n'est pas constante, tu reçoit un paramètre 'liste' constant donc tu ne peux utiliser que des fonctions constantes (const)

[bertry]

En effet Raymond,

Ta fonction begin() telle que déclarée dans le .h n'est pas constante

J'ai changé la fonction begin en fontion constante et ça a levé la première erreur de compilation... Mais il reste d'autres erreurs
Je travail sur leur résolution et je prolongerai cette dicussion si je sèche

[bertry]

Bon ben j'ai solutionné les autres bugs
Encore merci ram-0000

[Emmanuel Deloget]

Etant donné que tu as déjà implémenté le constructeur par copie, tu peux réfler le problème de manière beaucoup plus simple, en utilisant swap() dans l'opérateur de 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
16
 
#include <algorithm>
 
template <class T> LSC<T>& LSC<T>::operator=(const LSC<T>& other)
{
  LSC<T>(other).swap(*this);
  return *this;
}
 
// il faut aussi définir une méthode swap dans LSC<T>
template <class T> void LSC<T>::swap(LSC<T>& other)
{
  std::swap(debug, other.debut);
  std::swap(fin, other.fin);
  std::swap(size, other.size);
}

Deux avantages : si le constructeur par copie balance une exception, alors tu n'auras pas modifié le contenu de la liste courante ; son état restera donc utilisable. swap() ne lançant aucune exception, une fois le constructeur par copie obtenu, tu garanti la réussite de la copie.