Comment se spécialiser fonctions membres en fonction des arguments de modèle de classe

Question

Que dit la question. De plus, est-il possible de le faire 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 ce genre de 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. Dans le cas contraire, la première est instancié; si elle est, le second est instancié.

Les tests de trait de type is_same pour assurer T et U sont du même type. Il est utilisé pour faire en sorte que le modèle de fonction membre n'est pas instancié pour tout type autre que Foo<T>.

Cet exemple utilise la bibliothèque C ++ 0x <type_traits>; Boost a également une bibliothèque de traits de type que vous pouvez utiliser, qui fonctionne essentiellement les mêmes.

Answer 2

Vous ne avez pas besoin de faire quoi que ce soit compliqué. Il suffit d'utiliser la surcharge et la délégation. Notez que nous ne pouvons pas simplement ajouter une surcharge de 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 par la 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) {
  /* ... */
}

En utilisant la spécialisation de cette façon est possible que si tous les arguments de modèle sont fixés. En d'autres termes, spécialisée en partie la fonction de membre n'est pas possible.

Answer 3

Vous pouvez essayer de faire quelque chose comme ça (n'a pas testé, peut-être pas le travail):

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