Comprendre (simple?) C ++ Spécialisation de modèle partiel

Partielle de la spécialisation d'un modèle de fonction, si elle est membre de la fonction de modèle autonome ou de la fonction de modèle, n'est pas autorisé par la Norme:

template<typename T, typename U> void f() {} //okay  - primary template
template<typename T> void f<T,int>() {}      //error - partial specialization
template<> void f<unsigned char,int>() {}    //okay  - full specialization

Mais vous pouvez partiellement spécialiser le modèle de classe elle-même. Vous pouvez faire quelque chose comme ceci:

template <class A>
class Thing<A,int>  //partial specialization of the class template
{
    //..
    int doSomething();
};

template <class A>
int Thing<A,int>::doSomething()  { /* do whatever you want to do here */ }

Noter que lorsque vous avez en partie spécialiser une classe de modèle, puis le paramètre de modèle-liste des membres et leur fonction (dans sa définition en dehors de la classe), doit correspondre à le paramètre de modèle de liste de la classe de modèle partiel de la spécialisation. Cela signifie que, pour la ci-dessus partielle de la spécialisation de la classe de modèle, vous ne pouvez pas définir ce:

template <class A>
int Thing<A,double>::doSomething(); //error

Il n'est pas permis, car le paramètre de modèle de liste de définition de la fonction ne correspond pas au paramètre de modèle de liste de la classe de modèle partiel de la spécialisation. §14.5.4.3/1 de la Norme (2003) dit,

Le paramètre de modèle de liste d'un membre d'un modèle de classe partielle spécialisation doit correspondre à le paramètre de modèle de liste de la classe de modèle partiel de la spécialisation.[...]

Pour en savoir plus, lire ma réponse ici:

C++ - Surcharge basé sur un modèle de la méthode de classe, une partie specilization de cette méthode

---

Quelle est donc la solution? Souhaitez-vous en partie spécialiser votre classe ainsi que tout le travail répétitif?

Une solution simple serait de travail de la délégation, à la place de la en partie spécialisée de la classe de modèle. Écrire un autonome modèle de fonction et de se spécialiser comme suit:

template <class B>
B doTheActualSomething(B & b) { return b;  }

template <>
int doTheActualSomething<int>(int & b) { return b + 1; }

Et ensuite appeler cette fonction à partir d'un modèle doSomething() fonction de membre:

template <class A, class B>
B Thing<A,B>::doSomething() { return doTheActualSomething<B>(b_); }

---

Puisque dans votre cas particulier, doTheActualSomething besoin de connaître la valeur de un seul membre, à savoir b_la solution ci-dessus est très bien, que vous pouvez transmettre la valeur de la fonction en tant qu'argument dont le type est le modèle type argument Bet de la spécialisation pour int est possible d'être plein de spécialisation.

Mais imaginez si elle a besoin d'accéder à plusieurs membres, type de chacun dépend du modèle de type liste d'arguments, puis de définir un stand-alone, fonction modèle ne résout pas le problème, car il n'y en aura plus d'une type argument de la fonction de modèle, et vous ne pouvez pas partiellement spécialiser la fonction pour juste, disons, un type (comme il n'est pas permis).

Dans ce cas, vous pouvez définir un modèle de classe au lieu de cela, ce qui définit une statique non-modèle de fonction de membre doTheActualSomething. Voici comment:

template<typename A, typename B>
struct Worker
{
   B doTheActualSomething(Thing<A,B> *thing)
   {
      return thing->b_;
   }
};

//partial specialization of the class template itself, for B = int
template<typename A>
struct Worker<A,int>
{
   int doTheActualSomething(Thing<A,int> *thing)
   {
      return thing->b_ + 1;
   }
};

Notez que vous pouvez utiliser thing pointeur pour accéder à tout membre de la classe. Bien sûr, si elle doit accéder aux membres privés, alors vous avez à faire struct Worker un ami de Thing modèle de classe, comme:

//forward class template declaration
template<typename T, typename U> struct Worker

template <class A, class B>
class Thing
{
    template<typename T, typename U>  friend struct Worker; //make it friend
   //...
};

Maintenant déléguer le travail à l'ami:

template <class A, class B>
B Thing<A,B>::doSomething()
{
    return Worker<A,B>::doTheActualSomething(this); //delegate work
}

Deux points à noter ici:

• Dans cette solution, doTheActualSomething n'est pas une fonction membre modèle. Ses pas la classe englobante qui est modèle. Par conséquent, nous pouvons partiellement spécialiser le modèle de classe à tout moment, pour obtenir l'effet désiré de la partielle fonction membre template de la spécialisation.
• Puisque nous passons this pointeur en argument à la fonction, nous pouvons accéder à tout membre de la classe Thing<A,B>même privé des membres, comme Worker<T,U> est aussi un ami.

Complète de démonstration en ligne : http://www.ideone.com/uEQ4S

---

Maintenant il y a encore une chance d'amélioration. Maintenant, toutes les instanciations de Worker modèle de classe sont des amis de tous les instanciation de Thing modèle de classe. Donc on peut limiter ce nombre à beaucoup d'amitié:

template <class A, class B>
class Thing
{
    friend struct Worker<A,B>; //make it friend
   //...
};

Maintenant, une seule instanciation de Worker modèle de classe est un ami de l'un à l'instanciation de Thing modèle de classe. C'est un-à-un à l'amitié. C'est, Worker<A,B> est un ami de Thing<A,B>. Worker<A,B> n'est PAS un ami de Thing<A,C>.

Ce changement nous oblige à écrire le code d'une façon un peu différente. Voir la démo complète, avec la commande de classe et des définitions de fonction et tous:

http://www.ideone.com/6a1Ih