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"

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

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