spécialisation du procédé partiel de C

Question

Y at-il une spécialisation partielle pour la méthode de la classe de modèle?

 template <class A, class B>
 class C
 {
  void foo();
 }

il ne fonctionne pas de se spécialiser comme ceci:

template <class A> void C<A, CObject>::foo() {};

Toute aide?

Answer 1

Si vous avez déjà la classe spécialisée que vous pourriez donner différentes de mise en œuvre foo en classe spécialisée:

template<typename A, typename B>
class C
{
public:
    void foo() { cout << "default" << endl; };
};

template<typename A>
class C<A, CObject>
{
public:
  void foo() { cout << "CObject" << endl; };
};

---

Pour se spécialiser dans la fonction membre Visual C ++ 2008, vous pouvez le faire aussi modèle:

template<typename A, typename B>
class C
{
  template<typename T>
  void foo();

  template<>
  void foo<CObject>();
};

La solution ci-dessus semble ne sera disponible que dans le futur standard C ++ (selon le projet n2914 14.6.5.3/2).

Answer 2

Je pense qu'il ya un malentendu.

Il existe deux types de modèles:

• les classes de modèle
• les méthodes de modèle

Dans votre exemple, vous avez une classe de modèle, qui contient bien sûr des méthodes. Dans ce cas, vous devrez spécialiser la classe.

template <class A>
class C<A,CObject>
{
  void foo() { ... } // specialized code
};

Le problème dans votre exemple est relativement simple:. Vous définir la méthode foo pour la spécialisation C, mais cette spécialisation n'a jamais été déclarés avance

Le problème ici est que vous devez spécialiser pleinement votre classe C (et donc la copie d'un grand nombre de données). Il y a un certain nombre de solutions de contournement.

• Héritage (Composition?): Tout le travail commun dans une classe de base, alors la classe C hérite et se spécialiser selon le cas
• ami: au lieu d'avoir la méthode « foo » être membre de C, définir comme un ami des fonctions libres et se spécialiser uniquement cette méthode
• Délégation: a votre méthode « foo » appeler une autre méthode « bar », qui est une fonction libre, et se spécialisent « bar » de façon appropriée

Ce qui donne dans le code:

// 1- Inheritance
template <class A, class B>
class CBase
{
  // Everything that does not require specialization
};

template <class A, class B>
class C: public CBase<A,B>
         // depending on your need, consider using another inheritance
         // or even better, composition
{
  void foo(); // generic
};

template <class A>
class C<A,CObject> : public CBase<A,CObject>
{
  void foo(); // specialized
};

// 2- Friend
// note the change in signature:
// - now you need to pass the attributes to be changed
// - the last parameter helps differentiating the overload
//   as there is no specialization for functions
template <class A, class B> void foo(Arg1&, Arg2&, const B&);
template <class A> void foo(Arg1&, Arg2&, const CObject&);

template <class A, class B>
class C
{
  friend template <class, class> foo;
};

// 3- Delegation
// same signature as foo in (2)
template <class A, class B> void bar(Arg1&, Arg2&, const B&);
template <class A> void bar(Arg1&, Arg2&, const CObject&);

template <class A, class B>
class C
{
  void foo() { bar(member1, member2, B()); }
};

Espérons qu'il clarifie et aide!

Answer 3

Non, il n'y a pas de spécialisation de modèle de fonction partielle dans C ++ 0x à ajouter.

Comme correctement mentionné ci-dessus, en ce qui concerne les modèles de fonction essentiellement 2 choses ont été faites:

• arguments de modèle par défaut ont été mis à la disposition;
• modèles variadique ont été introduits.

Alors qu'auparavant, des solutions de contournement devraient être utilisés pour « imiter » la spécialisation des modèles de fonction partielle.

Answer 4

Étant donné que la classe est le modèle, vous devez se spécialiser que:

template <class A>
class C<A, CObject> 
{
   void foo() { ... }
}

Answer 5

Si je me souviens bien, vous ne pouvez pas faire la spécialisation de modèle partiel pour les fonctions. Je ne sais pas s'il est inclus dans C ++ 0X

Mise à jour: (En attente de confirmation) Comme il est indiqué dans les commentaires, la spécialisation de modèle partiel des fonctions est possible en C ++ 0X.