explicite de la spécialisation du modèle de fonction membre de classe

J'ai besoin de spécialiser modèle de fonction de membre d'un certain type (disons double). Il fonctionne très bien tandis que la catégorie X lui-même n'est pas un modèle de classe, mais lorsque je fais de modèle GCC commence à donner des erreurs de compilation.

#include <iostream>
#include <cmath>

template <class C> class X
{
public:
   template <class T> void get_as();
};

template <class C>
void X<C>::get_as<double>()
{

}

int main()
{
   X<int> x;
   x.get_as();
}

voici le message d'erreur

source.cpp:11:27: error: template-id
  'get_as<double>' in declaration of primary template
source.cpp:11:6: error: prototype for
  'void X<C>::get_as()' does not match any in class 'X<C>'
source.cpp:7:35: error: candidate is:
  template<class C> template<class T> void X::get_as()

Comment puis-je régler ce problème et quel est le problème ici?

Merci d'avance.

ce qui est illégal dans la norme actuelle, à se spécialiser, vous devez vous spécialiser la classe ainsi...
mais cela fonctionne si la classe n'est pas un modèle. Est-il illégal trop?
non, c'est parfaitement bien, c'est uniquement pour les modèles de classe que cette règle s'applique (autant que je sache).

InformationsquelleAutor ledokol | 2011-04-01

c++gcc specialization templates

93

Il ne fonctionne pas de cette façon. Vous auriez besoin de dire ce qui suit, mais il est pas corriger
```
template <class C> template<>
void X<C>::get_as<double>()
{

}
```
Explicitement spécialisé membres besoin autour des modèles de classe à être explicitement spécialisées ainsi. Vous devez donc vous dire la chose suivante, qui ne serait que de spécialiser les membres de X<int>.
```
template <> template<>
void X<int>::get_as<double>()
{

}
```
Si vous souhaitez conserver les environs modèle non spécialisé, vous avez plusieurs choix. Je préfère les surcharges
```
template <class C> class X
{
   template<typename T> struct type { };

public:
   template <class T> void get_as() {
     get_as(type<T>());
   }

private:
   template<typename T> void get_as(type<T>) {

   }

   void get_as(type<double>) {

   }
};
```
- pourquoi avez-vous besoin type<> wrapper? ne pouvait pas, un casting de un 0 à un pointeur de type T faire l'affaire? Je suppose que ce n'est pas aussi élégant...
- Regarde comme c'est vraiment pas possible de le faire. Merci.
- bon, je pense que le pointeur de la fonte chose, c'est moche, et ça ne marcherait pas pour les types que vous ne pouvez pas former des pointeurs vers des (références). Aussi, ayant un paramètre de fonction un pointeur sur un tableau de type sans taille est illégal en C++. L'avoir dans un de type wrapper qui fait que cela fonctionne pour tous les types.
- oups, j'ai oublié à propos des références... cette approche est nettement plus élégant..
- Quels sont les autres choix tout au long des surcharges ? Peut montrer certains d'entre eux ?
- Merci! J'aime cette réponse! Il est vraiment élégant et d'une façon curieuse d'avoir votre chemin sans en faire trop laid d'un hack... Pourriez-vous m'expliquer pourquoi le type<> wrapper est-elle nécessaire? Je n'ai pas très bien le commentaire de Nim, mais je suis désireux de comprendre ce que son commentaire était et pourquoi cette solution est mieux.. Merci!!!!!!
- son commentaire a été d'utiliser template<typename T> void get_as(T*); void get_as(double*); et passer un (T*)0.
- Dans la version actuelle de la norme, je vois que seul l'explicite spécialisations de modèle de classe membres est interdite si leur classe englobante modèles ne sont pas spécialisées ainsi (anguille.est/c++projet/temp.expl.spec#17). Est-il autre paragraphe de la norme qui interdit de manière explicite de la spécialisation de tous les membres? Je vous remercie.
- Je vois que d'autres ont la même interprétation que la vôtre. Suis-je la lecture de ce paragraphe de mal? Je vous remercie.
InformationsquelleAutor Johannes Schaub - litb

Si l'on est capable d'utiliser std::enable_if nous pouvions compter sur SFINAE (substitution de l'échec n'est pas une erreur)

qui fonctionne de la sorte:

#include <iostream>
#include <type_traits>

template <class C> class X
{
public:
    template <class T, typename std::enable_if< ! std::is_same<double,T>::value>::type * = nullptr > void get_as(){
        std::cout << "get as T" << std::endl;
    }


    template <class T, typename std::enable_if< std::is_same<double,T>::value>::type * = nullptr  > void get_as(){
        std::cout << "get as double" << std::endl;
    }
};


int main()
{

    X<int> d;
    d.get_as<double>();

   return 0;
}

Le laid, c'est que, avec toutes ces enable_if qu'une spécialisation doit être disponible pour le compilateur sinon homonymie erreur de se produire. C'est pourquoi le comportement par défaut "obtenir que T" doit également permettre si.

InformationsquelleAutor Gabriel

Vous devez vous connecter pour publier un commentaire.