Spécialisations partiels de template: accès aux membres.

Version imprimable

Bonjour,
Le code suivant ne compile pas:

Code:

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:

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...

03/09/2008, 18h12
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.
04/09/2008, 09h46
3DArchi

Ok merci. Mais je trouve ça embêtant d'avoir à redéfinir toute la spécialisation.
04/09/2008, 10h04
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.

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:

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; } };