Modèles de classes imbriquées

 

Les modèles peuvent être définis dans des classes ou des modèles de classe, auquel cas ils sont appelés modèles membres.Les modèles membres qui sont des classes sont appelés modèles de classe imbriqués.Les modèles membres qui sont des fonctions sont abordés dans la section Modèles de fonction membre.

Les modèles de classe imbriqués sont déclarés en tant que modèles de classe dans la portée de la classe externe.Ils peuvent être définis à l'intérieur ou à l'extérieur de la classe englobante.

Le code suivant illustre un modèle de classe imbriqué à l'intérieur d'une classe ordinaire.

// nested_class_template1.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

class X
{

   template <class T>
   struct Y
   {
      T m_t;
      Y(T t): m_t(t) { }   
   };

   Y<int> yInt;
   Y<char> yChar;

public:
   X(int i, char c) : yInt(i), yChar(c) { }
   void print()
   {
      cout << yInt.m_t << " " << yChar.m_t << endl;
   }
};

int main()
{
   X x(1, 'a');
   x.print();
}

Sortie

1 a

Lorsque les modèles de classe imbriqués sont définis en dehors de leur classe englobante, ils doivent être précédés des paramètres de modèle pour le modèle de classe (s'ils sont membres d'un modèle de classe) et des paramètres de modèle pour le modèle membre.

// nested_class_template2.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

template <class T>
class X
{
   template <class U> class Y
   {
      U* u;
   public:
      Y();
      U& Value();
      void print();
      ~Y();
   };

   Y<int> y;
public:
   X(T t) { y.Value() = t; }
   void print() { y.print(); }
};

template <class T> 
template <class U>
X<T>::Y<U>::Y()
{
   cout << "X<T>::Y<U>::Y()" << endl;
   u = new U();
}

template <class T> 
template <class U>
U& X<T>::Y<U>::Value()
{
   return *u;
}

template <class T> 
template <class U>
void X<T>::Y<U>::print()
{
   cout << this->Value() << endl;
}

template <class T> 
template <class U>
X<T>::Y<U>::~Y()
{
   cout << "X<T>::Y<U>::~Y()" << endl;
   delete u;
}

int main()
{
   X<int>* xi = new X<int>(10);
   X<char>* xc = new X<char>('c');
   xi->print();
   xc->print();
   delete xi;
   delete xc;
}

Sortie

X<T>::Y<U>::Y()
X<T>::Y<U>::Y()
10
99
X<T>::Y<U>::~Y()
X<T>::Y<U>::~Y()

Les classes locales ne doivent pas avoir de modèles membres.

Voir aussi

Modèles de classe
Modèles de fonctions membres