Comment spécialiser les fonctions membres en fonction de l'argument du modèle de classe

Question

Ce que dit la question. En outre, est-il possible de faire cela en ligne?

Voici un petit exemple juste pour donner une idée ...

template<typename T> 
class Foo { 
public: 
    Foo() :z(0.0) {} 

    void do(const Foo<T> &f) { 
    z = f.z; 
    } 
    // specialize 'do' for Foo<int>, possible inline? 

private: 
    T z; 
}; 

Answer 1

Vous pouvez obtenir sorte de ce comportement en faisant la fonction de membre d'un modèle de fonction membre et en utilisant SFINAE (échec de substitution n'est pas une erreur). Par exemple:

template <typename U> 
typename std::enable_if<!std::is_integral<U>::value && 
         std::is_same<T, U>::value, void>::type 
f(const Foo<U>& x) 
{ 
} 

template <typename U> 
typename std::enable_if<std::is_integral<U>::value && 
         std::is_same<T, U>::value, void>::type 
f(const Foo<U>& x) 
{ 
} 

Le test de trait de type is_integral si U est un type entier. Si ce n'est pas le cas, le premier est instancié; si c'est le cas, la seconde est instanciée.

Les tests de caractéristiques de type is_same pour assurer T et U sont du même type. Ceci est utilisé pour s'assurer que le modèle de fonction membre n'est instancié pour aucun type autre que Foo<T>.

Cet exemple utilise la bibliothèque C++ 0x <type_traits>; Boost a également a type traits library que vous pouvez utiliser, qui fonctionne la plupart du temps la même chose.

Answer 2

Vous pouvez essayer de faire quelque chose comme ça (ne pas tester, pourrait ne pas fonctionner):

template<typename T> 
class Foo { 
public: 
    Foo() :z(0.0) {} 

    template<typename Ty = T> 
    void do(const Foo<T> &f) { 
    z = f.z; 
    } 

    template<> 
    void do<int>(const Foo<T> &f) { 
    //specialized code 
    } 

private: 
    T z; 
}; 

Answer 3

Vous n'avez pas besoin de faire quoi que ce soit compliqué. Utilisez simplement la surcharge et la délégation. Notez que nous ne pouvons pas simplement ajouter une surcharge int, parce que quand T se révèle être int aussi, ce serait une surcharge invalide (deux fonctions avec la même signature)

template<typename T> 
class Foo { 
public: 
    Foo() :z(0.0) {} 

    void doIt(const Foo<T> &f) { 
    doItImpl(f); 
    } 

private: 
    template<typename U> 
    void doItImpl(const Foo<U> &f) { 
    z = f.z; 
    } 

    void doItImpl(const Foo<int> &f) { 
    /* ... */ 
    } 

private: 
    T z; 
}; 

Ou, pour ce cas, vous pouvez le faire ceci par spécialisation

template<typename T> 
class Foo { 
public: 
    Foo() :z(0.0) {} 

    void doIt(const Foo<T> &f) { 
    z = f.z; 
    } 

private: 
    T z; 
}; 

template<> 
inline void Foo<int>::doIt(const Foo<int> &f) { 
    /* ... */ 
} 

L'utilisation de la spécialisation de cette manière n'est possible que si tous les arguments du modèle sont corrigés. En d'autres termes, la spécialisation partielle de la fonction membre n'est pas possible.