Discussion :

[TNT89]

Bonsoir a tous,

Je viens de passer quelques longues a comprendre un problème relativement ennuyeux qui me conduisait a utiliser de façon silencieuse l'opérateur de copie par défaut, et cela avec des classes ayant des pointeurs pour membres...

Je peux reproduire le comportement avec le code suivant :

header.hpp

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
 
#ifndef __TEST_HEADER__
#define __TEST_HEADER__
 
	template<typename T>
	class D;
 
	template<typename T>
	class C
	{
		private :
			T a;
 
		public :
			C(const T& _a)
			 : a(_a)
			{ }
 
			C(const C<T>& c)
			 : a(c.a)
			{ }
 
			// Utile pour la suite :
			/*C<T>& operator=(const C<T>& c)
			{
				std::cout << "From const C& operator=(const C<T>& c)";
				return *this;
			}*/
 
			template<typename Tin>
			C<T>& operator=(const C<Tin>& c)
			{
				std::cout << "From const C& operator=(const C<Tin>& c)";
				return *this;
			}
	};
 
	template<typename T>
	class D : public C<T>
	{
		private :
			T b;
 
		public :
			D(const T& _b)
			 : C<T>(0), b(_b)
			{ }
 
			D<T>(const C<T>& c)
			 : C<T>(c), b(c.b)
			{ }
 
			using C<T>::operator=;
	};
 
#endif

main.cpp

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
 
#include <iostream>
#include "header.hpp"
 
int main(int argc, char** argv)
{
	std::cout << "Testing" << std::endl;
 
	C<int> c1(1), c2(2);
	D<int> d1(3), d2(4);
 
	std::cout << "1 : ";
	c1 = c2;
	std::cout << std::endl;
 
	std::cout << "2 : ";
	d1 = c1;
	std::cout << std::endl;
 
	std::cout << "3 : ";
	d1 = d2;	
	std::cout << std::endl;
 
	return 0;
}

Avec G++/4.4.5, cela affiche :

Code :

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

1
2
3
4
5
 
Testing
1 : 
2 : 
3 :

Comme vous pouvez le constater, il y a appel a l'opérateur = par défaut ce qui est dans mon code extrêmement grave. Au contraire, si je dé-commente la section donnée dans le fichier d'en-tête, j'ai bien :

Code :

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

1
2
3
4
5
 
Testing
1 : From const C& operator=(const C<T>& c)
2 : From const C& operator=(const C<T>& c)
3 : From const C& operator=(const C<T>& c)

Alors pourquoi le type propre de C est-t-il exclu de son opérateur = lui même template?

Merci,

[Flob90]

Bonjour,

C'est un comportement normal du C++. Les conditions à remplir pour la génération automatique des fonctions membres spéciales d'un classe ne prennent pas en compte les fonctions template. Tu dois donc explcitement écrire l'opérateur d'affectation pour le type de ta classe.

NB: Inutile d'écrire C<T> au sein de ta classe template (si le paramètre template de la classe est T), C est synonyme de C<T> au sein de celle-ci. Dit autrement n'écrit C<U> que si tu veux faire référence à une autre instance de C<> que celle que tu es en train d'écrire.

[JolyLoic]

Une autre formulation est de dire qu'un constructeur template ne peut pas être une constructeur de copie, et idem pour un opérateur d'affectation template.

[TNT89]

Merci pour vos réponses!