Problème de spécialisation de gabarit

Question

J'essaye vraiment de faire ce travail, mais je n'ai pas de chance. Je suis sûr qu'il y a du travail, mais je ne l'ai pas encore rencontré. Bon, voyons si je peux décrire le problème et les besoins simplement assez:

J'ai une classe de modèle RVB qui peut prendre des noms de types comme l'un de ses paramètres de modèle. Il prend le nom de type et l'envoie dans un autre modèle qui crée une classification de son type de base. Par exemple:

struct float_type {}; 
struct bit_type {}; 
struct fixed_pt_type {}; 

template <typename T> struct type_specification { typedef float_type type; }; 

template <> struct type_specification<char>  { typedef bit_type type; }; 
template <> struct type_specification<short>  { typedef bit_type type; }; 
template <> struct type_specification<int>  { typedef bit_type type; }; 
template <> struct type_specification<long>  { typedef bit_type type; }; 
template <> struct type_specification<long long> { typedef bit_type type; }; 

Puis, avec cela, j'ai un modèle qui calcule les valeurs Max pour chacune des valeurs RVB en fonction de son bit compte:

template <int Bits, typename T> struct Max_Values { enum { MaxValue = (1 << Bits) - 1; }; }; 
template <int Bits> struct MaxValues<float_type> { enum { MaxValue = 1.0; }; }; 

ensuite dans la classe réelle du modèle RVB, je ai:

enum 
{ 
    RMax = Max_Values<RBits, type_specification<T>::type>::MaxValue; 
    GMax = Max_Values<GBits, type_specification<T>::type>::MaxValue; 
    BMax = Max_Values<BBits, type_specification<T>::type>::MaxValue; 
}; 

Cela fonctionne très bien pour moi, jusqu'à ce que je suis entré dans les besoins fixes-pt. La valeur max est un peu différente et je ne sais pas comment créer une spécialisation de spécification de type pour l'isoler. Le seul travail autour de moi est le processus d'élimination et de création de spécialisations pour float et double et en supposant que le cas général sera fixé-pt. Mais il doit y avoir une meilleure façon de faire cela. Voici ce que je veux faire avec code incorrect:

template <> struct type_specification<fixed_pt_t> { typedef fixed_pt_type type; }; 

Cependant, fixe-pt-T est une classe de modèle qui ressemble à:

template <int N, typename T, template <class> class Policy> struct fixed_pt_t 

Ainsi, le compilateur n'aime pas la spécialisation sans modèle paramètres.
Y at-il un moyen de spécialiser ma classe de spécification de type pour travailler avec fixed-pt-t?
Cela fonctionne très bien pour le cas général, ne peut tout simplement pas l'isoler.

Answer 1

Peut-être qu'il me manque une complication plus grande, mais y a-t-il une raison pour laquelle vous ne pouvez pas seulement spécialiser partiellement le modèle type_specification?

Quelque chose comme ceci:

template <int N, typename T, template <class> class Policy> 
struct type_specification< fixed_pt_t<N, T, Policy> > 
{ 
    typedef fixed_pt_type type; 
};