Discussion :

[3DArchi]

Bonjour,
Le code suivant ne compile pas:

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
 
template<class T> class A {
public:
   A(const T&P_oT0) :m_Membre(P_oT0) {}
protected:
   T m_Membre;
};
 
template<> class A<double> {
public:
   double MaFonction() {return m_Membre*1.5;}
};
 
int main()
{
   A<double> L_aDouble(4.0); // KO
   A<int> L_aInt(4); // OK
   A<char> L_aChar('e'); // OK
   return 0;
}

J'ai une erreur m'indiquant que m_Membre est inconnu dans MaFonction et le constructeur A(const T&P_oT0) n'est pas trouvé.
Je suis obligé de faire:

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
template<class T> class A {
public:
   A(const T&P_oT0) :m_Membre(P_oT0) {}
protected:
   T m_Membre;
};
 
template<> class A<double> {
public:
   A(const double&P_oT0) :m_Membre(P_oT0) {}
   double MaFonction() {return m_Membre*1.5;}
 
protected:
   double m_Membre;
};
 
int main()
{
   A<double> L_aDouble(4.0); // OK
   A<int> L_aInt(4); // OK
   A<char> L_aChar('e'); // OK
   return 0;
}

J'ai loupé quelque chose? Sinon, si je doit reprendre toute les définitions dans mes spécialisations, cela devient un peu galère...

[Spout]

Quand tu spécialises une classe template, il faut que tu spécialise toute la classe. Il te manquuait donc la spécialisation double de m_Membre et du constructeur, ce que tu as rajouté dans ton 2e code.

Cf FAQ.

[3DArchi]

Ok merci. Mais je trouve ça embêtant d'avoir à redéfinir toute la spécialisation.

[Spout]

C'est le problème avec les classes template. Si je ne me trompe pas, le compilateur peut choisir de ne pas générer la totalité ou une partie du code d'une classe template s'il n'est pas utilisé.
Tu indiques que tu utilises la spécialisation double de ta classe, le compilateur ne va alors plus s'occuper de l'autre. Mais il ne va également pas trouver tout ce qui l'intéresse dans la spécialisation.

[3DArchi]

J'ai trouvé une demi-solution en passant par une classe parent et en héritant. J'évite la re-définition de mes membres à l'exception bien sûr du constructeur et de la spécialisation de l'héritage:

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
template<class T>
class BaseA
{
public:
   BaseA(const T&P_oT0):m_Membre(P_oT0){}
protected:
   T m_Membre;
};
 
template<class T>
class A :public BaseA<T>
{
public:
   A(const T&P_oT0):BaseA(P_oT0){}
protected:
};
 
template<>
class A<double> :public BaseA<double>
{
public:
   A(const double&P_oT0):BaseA(P_oT0){}
   double MaFonction()
   {
      return m_Membre*1.5;
   }
};