Spécialisation partielle et typedef de template.

Bonjour,
J'ai une classe template quelconque :

Code:

---

template<class T>struct ok {};

---

Je déclare une classe trait :

Code:

---

template<class T> struct trait;

---

et je la spécialise pour ma première classe template :

Code:

---

1 2 3 4 5 6

template<class T> struct trait<ok<T> > { static const std::string tell_me; }; template<class T> const std::string trait<ok<T> >::tell_me="ok<T>";

---

Ca marche :

Code:

---

1 2 3 4 5 6

#include <iostream> int main() { std::cout<<trait<ok<double> >::tell_me <<std::endl; return 0; }

---

Jusque là tout va bien.
Mais en attendant les alias de template, je fais ça :

Code:

---

1 2 3 4 5 6

template<class T> struct problem {}; template<class T> struct rebind { typedef problem<T> type; };

---

Et lorsque j'essaie de spécialiser partiellement ma classe trait :

Code:

---

1 2 3 4 5 6

template<class T> struct trait<typename rebind<T>::type > { static const std::string tell_me; }; template<class T> const std::string trait<typename rebind<T>::type >::tell_me="problem<T>";

---

Je me fais jeter :aie:

Citation:

---

Envoyé par VCExpress

error C2764: 'T'*: paramètre de modèle non utilisé ou pouvant être déduit dans la spécialisation partielle 'trait<rebind<T>::type>'

---

Citation:

---

Envoyé par MinGW

error: template parameters not used in partial specialization

---

Je comprend pas pourquoi le code est incorrect. Mais surtout, je vois pas comment contourner sauf à faire :

Code:

---

1 2 3 4 5 6

template<class T> struct trait<problem<T> >/*<typename rebind<T>::type >*/ { static const std::string tell_me; }; template<class T> const std::string trait<problem<T> >::tell_me="rebind<T>";

---

car bien sur dans la vraie vie problem<T> est un peu plus compliqué que ça.

Avez-vous des idées/solutions ?

Hum chez moi le code que tu fournies compile, et à première vue je vois pas de raisons qui ferait que ça compile pas.

Citation:

---

Envoyé par Goten

Hum chez moi le code que tu fournies compile, et à première vue je vois pas de raisons qui ferait que ça compile pas.

---

Ca :

Code:

---

1 2 3 4

template<class T> struct trait<typename rebind<T>::type > { static const std::string tell_me; };

---

Ne compile pas chez moi :calim2:
Voici un source complet :

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 28 29 30 31 32 33 34 35 36

#include <string>   template<class T> struct dummy { };   template<class T> struct trait; template<class T> struct trait<dummy<T> > { static const std::string tell_me; }; template<class T> const std::string trait<dummy<T> >::tell_me="dummy<T>";   template<class T> struct problem {}; template<class T> struct rebind { typedef problem<T> type; };   template<class T> struct trait<typename rebind<T>::type > { static const std::string tell_me; }; template<class T> const std::string trait<problem<T> >::tell_me="rebind<T>";   #include <iostream> int main() { std::cout<<trait<dummy<double> >::tell_me <<std::endl; std::cout<<trait<rebind<double>::type >::tell_me <<std::endl; return 0; }

---

En effet là ça compile pas. Autant pour moi juste le bout de code compilé, mais me manquer un copié ;).

edit : fiou... les copié collé aujourd'hui -_-

A partir d'un type foo, tu ne peux jamais deduire quel est le type T qui correspond a typename rebind<T>::type, donc la specialisation partielle est inutilisable. Tout comme avec

Code:

---

template <class T> int bar(typename rebind<T>::type);

---

tu ne peux pas t'attendre a ce que le compilateur deduise de bar(exp) quel valeur de T il doit utiliser.

Les messages d'erreur ne sont pas geniaux. Celui de VC me semble meme mal redige (pb de traduction?). Si j'aurais bien vu une negation: "... ne pouvant être déduit"

Tu as donné la réponse toi même, ce n'est pas valide.
Ca fonctionnait avec GCC 4.1.2, depuis plus, et c'est voulu.

Le compilateur ne peut déduire T à partir de rebind< T >::type.

http://gcc.gnu.org/ml/gcc-patches/2008-01/msg00482.html

(erf trop lent)

Citation:

---

Envoyé par Jean-Marc.Bourguet

A partir d'un type foo, tu ne peux jamais deduire quel est le type T qui correspond a typename rebind<T>::type, donc la specialisation partielle est inutilisable.

---

J'ai l'impression de comprendre mais comme j'arrive pas à le formuler en terme clair, ça me dérange.

J'ai le sentiment que je raisonnais à l'envers. Je partais de mes définitions et aboutissait à une expression. En fait le compilo fonctionne à l'envers : à partir de l'expression il détermine quelle spécialisation s'applique et il ne peut utiliser celle-ci.

Citation:

---

Envoyé par 3DArchi

J'ai l'impression de comprendre mais comme j'arrive pas à le formuler en terme clair, ça me dérange.

J'ai le sentiment que je raisonnais à l'envers. Je partais de mes définitions et aboutissait à une expression. En fait le compilo fonctionne à l'envers : à partir de l'expression il détermine quelle spécialisation s'applique et il ne peut utiliser celle-ci.

---

Comment veux-tu qu'il fasse autrement? Tu utilises traits<foo> (que tu ait optenu foo a partir d'un typedef dans un template ou autrement n'a pas d'importance, tu ne voudrais quand meme pas que ca intervienne, non?) et pour que la specialisation partielle soit utilisable, il faut pouvoir en deduire les parametres avec lesquelles la specialisation est instanciee.