Discussion :

[3DArchi]

Bonjour,
J'ai une classe template quelconque :

Code :

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

template<class T>struct ok {};

Je déclare une classe trait :

Code :

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

template<class T> struct trait;

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

Code :

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

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 :

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

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 :

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

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 :

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

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

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

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 :

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

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 ?

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

[3DArchi]

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 :

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

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

Ne compile pas chez moi
Voici un source complet :

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

[Goten]

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

[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. Tout comme avec

Code :

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

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"

[JulienDuSud]

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)

[3DArchi]

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.

[Jean-Marc.Bourguet]

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.