Modèles de classe C++
Modèles de classe C++
Dans ce didacticiel, nous allons découvrir les modèles de classe en C++ à l'aide d'exemples.
Les modèles sont des fonctionnalités puissantes de C++ qui nous permettent d'écrire des programmes génériques. Nous pouvons implémenter des modèles de deux façons :
- Modèles de fonction
- Modèles de cours
Comme pour les modèles de fonction, nous pouvons utiliser des modèles de classe pour créer une seule classe afin de travailler avec différents types de données.
Les modèles de classe sont pratiques car ils peuvent rendre notre code plus court et plus facile à gérer.
Déclaration de modèle de classe
Un modèle de classe commence par le mot-clé template suivi du ou des paramètres de modèle à l'intérieur de <> qui est suivi de la déclaration de classe.
template <class T>
class className {
private:
T var;
... .. ...
public:
T functionName(T arg);
... .. ...
};
Dans la déclaration ci-dessus, T est l'argument du modèle qui est un espace réservé pour le type de données utilisé, et class est un mot-clé.
Dans le corps de la classe, une variable membre var et une fonction membre functionName() sont tous deux de type T .
Création d'un objet de modèle de classe
Une fois que nous avons déclaré et défini un modèle de classe, nous pouvons créer ses objets dans d'autres classes ou fonctions (comme le main() fonction) avec la syntaxe suivante
className<dataType> classObject; Par exemple,
className<int> classObject;
className<float> classObject;
className<string> classObject; Exemple 1 :Modèles de classe C++
// C++ program to demonstrate the use of class templates
#include <iostream>
using namespace std;
// Class template
template <class T>
class Number {
private:
// Variable of type T
T num;
public:
Number(T n) : num(n) {} // constructor
T getNum() {
return num;
}
};
int main() {
// create object with int type
Number<int> numberInt(7);
// create object with double type
Number<double> numberDouble(7.7);
cout << "int Number = " << numberInt.getNum() << endl;
cout << "double Number = " << numberDouble.getNum() << endl;
return 0;
} Sortie
int Number = 7 double Number = 7.7
Dans ce programme. nous avons créé un modèle de classe Number avec le code
template <class T>
class Number {
private:
T num;
public:
Number(T n) : num(n) {}
T getNum() { return num; }
};
Notez que la variable num , l'argument constructeur n , et la fonction getNum() sont de type T , ou avoir un type de retour T . Cela signifie qu'ils peuvent être de n'importe quel type.
En main() , nous avons implémenté le modèle de classe en créant ses objets
Number<int> numberInt(7);
Number<double> numberDouble(7.7);
Remarquez les codes Number<int> et Number<double> dans le code ci-dessus.
Cela crée une définition de classe chacun pour int et float , qui sont ensuite utilisés en conséquence.
Il est obligatoire de spécifier le type lors de la déclaration des objets des modèles de classe. Sinon, le compilateur produira une erreur.
//Error
Number numberInt(7);
Number numberDouble(7.7); Définir un membre de classe en dehors du modèle de classe
Supposons que nous ayons besoin de définir une fonction en dehors du modèle de classe. Nous pouvons le faire avec le code suivant :
template <class T>
class ClassName {
... .. ...
// Function prototype
returnType functionName();
};
// Function definition
template <class T>
returnType ClassName<T>::functionName() {
// code
}
Notez que le code template <class T> est répété lors de la définition de la fonction en dehors de la classe. Ceci est nécessaire et fait partie de la syntaxe.
Si nous regardons le code dans Exemple 1 , nous avons une fonction getNum() défini dans le modèle de classe Number .
Nous pouvons définir getNum() en dehors de Number avec le code suivant :
template <class T>
class Number {
... .. ...
// Function prototype
T getnum();
};
// Function definition
template <class T>
T Number<T>::getNum() {
return num;
} Exemple 2 :calculatrice simple utilisant des modèles de cours
Ce programme utilise un modèle de classe pour effectuer l'addition, la soustraction, la multiplication et la division de deux variables num1 et num2 .
Les variables peuvent être de n'importe quel type, bien que nous n'ayons utilisé que int et float types dans cet exemple.
#include <iostream>
using namespace std;
template <class T>
class Calculator {
private:
T num1, num2;
public:
Calculator(T n1, T n2) {
num1 = n1;
num2 = n2;
}
void displayResult() {
cout << "Numbers: " << num1 << " and " << num2 << "." << endl;
cout << num1 << " + " << num2 << " = " << add() << endl;
cout << num1 << " - " << num2 << " = " << subtract() << endl;
cout << num1 << " * " << num2 << " = " << multiply() << endl;
cout << num1 << " / " << num2 << " = " << divide() << endl;
}
T add() { return num1 + num2; }
T subtract() { return num1 - num2; }
T multiply() { return num1 * num2; }
T divide() { return num1 / num2; }
};
int main() {
Calculator<int> intCalc(2, 1);
Calculator<float> floatCalc(2.4, 1.2);
cout << "Int results:" << endl;
intCalc.displayResult();
cout << endl
<< "Float results:" << endl;
floatCalc.displayResult();
return 0;
} Sortie
Int results: Numbers: 2 and 1. 2 + 1 = 3 2 - 1 = 1 2 * 1 = 2 2 / 1 = 2 Float results: Numbers: 2.4 and 1.2. 2.4 + 1.2 = 3.6 2.4 - 1.2 = 1.2 2.4 * 1.2 = 2.88 2.4 / 1.2 = 2
Dans le programme ci-dessus, nous avons déclaré un modèle de classe Calculator .
La classe contient deux membres privés de type T :num1 &num2 , et un constructeur pour initialiser les membres.
Nous avons aussi add() , subtract() , multiply() , et divide() les fonctions qui ont le type de retour T . Nous avons aussi un void fonction displayResult() qui imprime les résultats des autres fonctions.
En main() , nous avons créé deux objets de Calculator :un pour int type de données et un autre pour float type de données.
Calculator<int> intCalc(2, 1);
Calculator<float> floatCalc(2.4, 1.2); Cela invite le compilateur à créer deux définitions de classe pour les types de données respectifs lors de la compilation.
Modèles de classe C++ avec plusieurs paramètres
En C++, nous pouvons utiliser plusieurs paramètres de modèle et même utiliser des arguments par défaut pour ces paramètres. Par exemple,
template <class T, class U, class V = int>
class ClassName {
private:
T member1;
U member2;
V member3;
... .. ...
public:
... .. ...
}; Exemple 3 :Modèles C++ avec plusieurs paramètres
#include <iostream>
using namespace std;
// Class template with multiple and default parameters
template <class T, class U, class V = char>
class ClassTemplate {
private:
T var1;
U var2;
V var3;
public:
ClassTemplate(T v1, U v2, V v3) : var1(v1), var2(v2), var3(v3) {} // constructor
void printVar() {
cout << "var1 = " << var1 << endl;
cout << "var2 = " << var2 << endl;
cout << "var3 = " << var3 << endl;
}
};
int main() {
// create object with int, double and char types
ClassTemplate<int, double> obj1(7, 7.7, 'c');
cout << "obj1 values: " << endl;
obj1.printVar();
// create object with int, double and bool types
ClassTemplate<double, char, bool> obj2(8.8, 'a', false);
cout << "\nobj2 values: " << endl;
obj2.printVar();
return 0;
} Sortie
obj1 values: var1 = 7 var2 = 7.7 var3 = c obj2 values: var1 = 8.8 var2 = a var3 = 0
Dans ce programme, nous avons créé un modèle de classe, nommé ClassTemplate , avec trois paramètres, dont l'un est un paramètre par défaut.
template <class T, class U, class V = char>
class ClassTemplate {
// code
};
Remarquez le code class V = char . Cela signifie que V est un paramètre par défaut dont le type par défaut est char .
À l'intérieur de ClassTemplate , on déclare 3 variables var1 , var2 et var3 , chacun correspondant à l'un des paramètres du modèle.
class ClassTemplate {
private:
T var1;
U var2;
V var3;
... .. ...
... .. ...
};
En main() , nous créons deux objets de ClassTemplate avec le code
// create object with int, double and char types
ClassTemplate<int, double> obj1(7, 7.7, 'c');
// create object with double, char and bool types
ClassTemplate<double, char, bool> obj2(8, 8.8, false); Ici,
| Objet | T | U | V |
|---|---|---|---|
| obj1 | int | double | char |
| obj2 | double | char | bool |
Pour obj1 , T = int , U = double et V = char .
Pour obj2 , T = double , U = char et V = bool .
Langue C