speciatlisation d 'une classe template par une classe template

Et me revoici avec un toy code
Ce que je cherche a faire ( sans toucher a AA)
c est de specialiser cette derniere ( sans toucher a sa caractérisation template)
par une classe template comme par exemple la classe CC

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

template<class S> struct AA { int f( int) { return -1; } };   struct BB{};   template<int n=3> struct CC{};   template<> int AA<BB>::f(int){ return 0; }   template<> int AA< template<int> CC >::f(int){ return 2; }   int _tmain(int argc, _TCHAR* argv[]) { AA<BB> b; // marche AA<CC<> > a; // marche pas return 0; }

---

ce que je propose ici ne compile pas bien sure. Je ne suis pas tres doué!!!

Code:

---

1 2 3 4 5 6 7

template<class S> struct AA { int f( int) { return -1; } };   struct BB{};

---

Jusque là, tout va bien.

Code:

---

1 2 3 4 5

template<int n=3> struct CC{};   template<> int AA<BB>::f(int){ return 0; }

---

Tu spéciales juste une méthode de ta classe template, alors que tu devrais spécialiser TOUTE ta classe template. Si c'est juste la méthode qui doit changer selon le paramètre template, c'est la méthode que tu dois rendre template.

Code:

---

1 2	template<> int AA< template<int> CC >::f(int){ return 2; }

---

Et là je commence à penser que tu mets de la mauvaise volonté. C'est la même chose que juste avant, sauf que comme AA attend un type en paramètre template, et non pas une "fonction de type" (un template, quoi), tu ne peux donner CC just for fun. CC est une "fonction de type" qui à un nombre (le paramètre n) associe un type. Si tu veux un type à l'arrivée, il faut lui donner un nombre. Donc tu pourrais éventuellement spécialiser ta classe AA pour CC<42> ou autre.

Code:

---

int _tmain(int argc, _TCHAR* argv[])

---

_tmain n'est absolument pas standard, ni _TCHAR*. Ton code ne compilera pas sur d'autres compilos, et peut-être plus dans des versions suivantes de ton compilo actuel qui se déciderait à suivre la norme.

en effet maintenant que tu le dis ca ne devrait meme pas compiler puisque je devrais surcharger la classe toute entiere .
Mais je ne parviens pas a resoudre le fond ( peu importe la forme).

le code suivant bien sure ne marche pas

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

struct AA { template <class S> int f( int) { return -1; } };   struct BB{};   template<int n=3> struct CC{};   template<> int AA::f<BB>(const int){ return 0; }   template<int n> int AA::f< CC<n> >(const int){ return 2; }     int main() { AA b;   int u = b.f<BB>(1); int v = b.f<CC<> >(1); return 0; }

---

j ai ce genre de messages:

Citation:

---

1>c:\program files\microsoft visual studio 9.0\project\solver\solver\solver.cpp(58) : error C2768: 'AA::f' : utilisation non conforme d'arguments template explicites
1>c:\program files\microsoft visual studio 9.0\project\solver\solver\solver.cpp(58) : error C2768: 'AA::f' : utilisation non conforme d'arguments template explicites
1>c:\program files\microsoft visual studio 9.0\project\solver\solver\solver.cpp(58) : error C2244: 'AA::f' : impossible de faire correspondre la définition de fonction avec une déclaration existante

---

le code suivant ( une fantaisie ) est pire encore

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

struct AA { template <class S> int f( int) { return -1; } };   struct BB{};   template<int n=3> struct CC{};   template<> int AA::f<BB>(const int){ return 0; }   template<> int AA::f< template < int n> CC >(const int){ return 2; }     int main() { AA b;   int u = b.f<BB>(1); int v = b.f<CC<> >(1); return 0; }

---

Si tu as une idee. Ca m interresse beaucoup

Tu devrais lire C++ Templates : The Complete Guide pour comprendre toutes les règles qui régissent le monde des templates. Ou la norme.

Parce qu'en essayant un peu tout comme ça tu vas plus t'arracher les cheveux qu'autre chose.

Je pense qu il va bien falloir
Car je me pose de plus en plus de question tordu.
Avec les templates on peut faire de la poesie ( plus ou moins reussie)