Modèle de la spécialisation et de l'héritage

Supposons que j'ai un modèle de classe avec beaucoup de fonctions et je veux me spécialiser à changer seulement quelques-uns d'entre eux et de garder les autres exactement comme spécifié dans le modèle de base de la classe.

Comment puis-je le faire?

Ci-dessous est ce que je veux réaliser, mais la solution n'est pas bonne, car elle ne me permet pas de se référer à la spécialisation pour int comme Base<int> – je besoin pour utiliser IntSpec pour que.

#include <iostream>

using namespace std;

template<typename T>
struct Base
{
  void print1() {cout << "Base::print1" << endl;};
  void print2() {cout << "Base::print2" << endl;};
};

struct IntSpec : public Base<int>
{
  void print2() {cout << "Base<int>::print2()" << endl;};
};

int main()
{
  Base<double> d;
  //Base<int> i;  <-- I want this kind of instantiation
  IntSpec i;

  d.print1();
  d.print2();
  i.print1();
  i.print2();
}

La sortie est:

Base::print1
Base::print2
Base::print1
Base<int>::print2()
InformationsquelleAutor Amadeus | 2013-06-12
  1. 27

    Nicol de la solution fonctionne très bien, mais c'est une alternative:

    template<typename T>
struct Base
{
  void print1() {cout << "Base::print1" << endl;};
  void print2() {cout << "Base::print2" << endl;};
};

template<>
void Base<int>::print2() {cout << "Base<int>::print2()" << endl;};

    De cette façon, vous pouvez vous spécialiser uniquement des fonctions de membre et de toujours utiliser ceux que vous n'avez pas spécialisées(dans ce cas, print1) sans aucun problème. Donc, maintenant que vous souhaitez utiliser comme vous voulais:

    Base<int> i;
i.print1();
i.print2(); //calls your specialization

    Démo ici.

    • Êtes-vous sûr que c'est la norme C++, ou un compilateur extension?
    • J'ai pour ma part toujours pensé que c'est parfaitement valide (et je me demandais pourquoi il n'était pas le top réponse tout de suite), mais qui n'a pas besoin de dire quoi que ce soit (bien que, je crois, me souviens avoir une fois explicitement cherché cette dans Vandevoorde-Josuttis, et l'a trouvé).
    • Je crois §l'article 14.7.3/14 permet de faire cela. Suis-je tort?
    InformationsquelleAutor mfontanini
  2. 20

    Vous avez juste à utiliser deux classes de modèles:

    template<typename T>
struct CommonBase
{
  void print1() {cout << "Base::print1" << endl;};
  void print2() {cout << "Base::print2" << endl;};
};

template<typename T>
struct Base : public CommonBase<T>
{
};

template<>
struct Base<int> : public CommonBase<int>
{
  void print2() {cout << "Base::print2" << endl;};
};

    Vous utilisez toujours Base, plutôt que de CommonBase.

    InformationsquelleAutor Nicol Bolas
  3. 4

    Une autre solution serait d'ajouter un niveau d'indirection dans la fonction que vous souhaitez redéfinir, c'est à dire

    template<typename T>
struct foo
{
    template<typename T2>
    void bar_impl()
    {
        //generic function
    }

    void bar()
    {
        bar_impl<T>();
    }
};

    Alors vous pouvez vous spécialiser chaque fonction séparément pour chaque type ou de se spécialiser tout type voulu.

    InformationsquelleAutor tiridactil