Exemple de modèle de classe C++ Array pour instancier un tableau de n’importe quel type d’élément

Dans cet article, nous allons voir comment utiliser des modèles de classe C++ pour créer un tableau capable de gérer n’importe quel type d’élément. Cela permet d’obtenir un code plus flexible et réutilisable en utilisant des modèles pour définir des classes génériques.

Dans ce tutoriel, vous allez apprendre :

• Comment définir un modèle de classe en C++
• Comment instancier une classe de modèle avec différents types de données

Définition et utilisation d’un modèle de classe C++

Les modèles de classe en C++ vous permettent de définir des classes qui peuvent fonctionner avec n’importe quel type de données. Vous trouverez ci-dessous un exemple de définition et d’utilisation d’un modèle de classe pour un tableau.

1. Définition du modèle de classe de tableau : le code suivant définit un tableau de classes de modèle qui peut être utilisé pour créer des tableaux de n’importe quel type.

   #ifndef ARRAY_H_
   #define ARRAY_H_
   
   #include 
   using std::cout;
   using std::endl;
   
   #include 
   using std::setw;
   
   #include 
   
   // define a clas array of type T
   // the type is not know yet and will 
   // be defined by instantiation 
   // of object of class array from main
   template< typename T > class array {
   private:
   	int size;
   	T *myarray;
   public:
   // constructor with user pre-defined size
   	array (int s) {
   	size = s;
   	myarray = new T [size];
   	}
   // calss array member function to set element of myarray 
   // with type T values
   void setArray ( int elem, T val) {
   	myarray[elem] = val;
   	}
   
   // for loop to display all elements of an array
   void getArray () {
        for ( int j = 0; j < size; j++ ) {
   // typeid will retriev a type for each value
           cout << setw( 7 ) << j << setw( 13 ) << myarray[ j ] 
   << " type: " << typeid(myarray[ j ]).name() << endl;
   	}
   	cout << "-----------------------------" << endl;
   	}
   };
   
   #endif

   Enregistrez ce code dans un fichier nommé array.h. Ce code illustre la déclaration d’une classe de modèle qui peut stocker et manipuler des tableaux de différents types de données.

2. Instanciation et utilisation de la classe de modèle : le code suivant montre comment instancier et utiliser la classe de modèle pour différents types de données.

   #include "array.h"
   int main() 
   {
   // instantiate int_array object of class array with size 2
   array< int > int_array(2);
   // set value to a first element
   // call to array class member function to set array elements
   int_array.setArray(0,3);
   // set value to a second element
   // NOTE: any attempt to set float to an int array will be translated to int value
   int_array.setArray(1,3.4);
   
   // call to array class member function to display array elements
   int_array.getArray();
   
   // instantiate float_array object of class array with size 3
   array< float > float_array(3);
   
   // set value to a first element
   // call to array class member function to set array elements
   float_array.setArray(0,3.4);
   // set value to a second element
   float_array.setArray(1,2.8);
   
   // call to array class member function to display array elements
   float_array.getArray();
   
   // instantiate float_array object of class array with size 5
   array< char > char_array(5);
   
   // set value to a first element
   // call to array class member function to set array elements
   char_array.setArray(0,'H');
   // set value to a other array elements
   char_array.setArray(1,'E');
   char_array.setArray(2,'L');
   char_array.setArray(3,'L');
   char_array.setArray(4,'O');
   
   char_array.getArray();
   
   return 0;
   }

Enregistrez ce code dans un fichier nommé main.cpp. Cette fonction principale instancie la classe de modèle pour les types int, float et char, démontrant ainsi la flexibilité des modèles de classe.

3. Compilation et exécution du programme : Compilez le code avec la commande suivante :

   g++ main.cpp -o myarray

   Exécutez le programme compilé avec la commande :

   ./myarray

   Résultats attendus :

         0            3 type: i
         1            3 type: i
   -----------------------------
         0          3.4 type: f
         1          2.8 type: f
         2            0 type: f
   -----------------------------
         0            H type: c
         1            E type: c
         2            L type: c
         3            L type: c
         4            O type: c
   -----------------------------

   

Conclusion

Ce petit exemple de programme C++ illustre l’utilisation de modèles en C++. Le « template class array » peut instancier des tableaux de n’importe quel type avec un seul constructeur et une seule fonction membre setArray.

Un tel comportement peut également être obtenu en surchargeant les constructeurs et la fonction membre setArray, mais cela nécessiterait des déclarations et des définitions de fonction membre distinctes pour chaque type de tableau.

Cet exemple de programme instancie trois types de tableaux différents : int, float et char avec un seul constructeur et une seule fonction membre à l’aide du modèle T de typename.