Templates en français
Introduction aux Templates en C++
Les templates en C++ permettent d'utiliser des types de données comme paramètres dans des fonctions et des classes, faisant de ces derniers ce qu'on appelle des types génériques. Cela offre la possibilité de définir un ensemble de classes ou de fonctions interconnectées capables de fonctionner avec une gamme variée de types, le tout à partir d'une seule déclaration.
Fonctions Templates
Les templates de fonctions sont des fonctions génériques, lesquelles peuvent être employées avec divers types.
Syntaxe :
template function;
Ici, typeidentifier
sert de nom de variable représentant le type générique, et function
représente la déclaration de la fonction utilisant ce type dans sa définition. Le typeidentifier
peut apparaître partout où un nom de type est attendu, y compris dans le type de retour.
Il est également possible de définir plusieurs identifiants de type, séparés par des virgules :
template function;
Pour appeler la fonction avec un paramètre de type, on utilise la syntaxe suivante :
function_name (parameters);
Pour un template avec plusieurs identifiants, il faut fournir une liste de types séparés par des virgules :
function_name (parameters);
Remarque : Si le typeidentifier
est utilisé pour des paramètres de fonction, le compilateur peut déterminer le type correspondant à partir de l'argument passé, permettant un appel à la fonction sans spécifier <type>
, tout comme avec une fonction classique.
Il est également possible d'utiliser le mot clé typename
comme synonyme de class
dans la définition d'un template :
Exemple : L'exemple suivant crée une fonction myAdd
capable d'utiliser n'importe quel type qui supporte l'opérateur +
:
#include
using namespace std;
template T myAdd(T x, T y) {
T result;
result = x + y;
return result;
}
int main() {
cout << myAdd (3, 7) << endl;
cout << myAdd (3.5, 7.2) << endl;
cout << myAdd ("Hello", " World!") << endl;
return 0;
}
Il en résulte :
10
10.7
Hello World!
Classes Templates
Les templates de classes sont des classes définies avec un type générique qui peut être utilisé dans l'entièreté de la définition de la classe.
Syntaxe :
template class;
Dans ce cas, typeidentifier
est une variable représentant le type générique, et class
est la déclaration de la classe, utilisant typeidentifier
dans sa définition. Comme pour un template de fonction, typeidentifier
peut être utilisé partout où un nom de type est attendu, et il est possible de définir la classe avec plusieurs paramètres de type.
La classe est référencée en code comme suit :
classname
Remarque : Si un membre de fonction est défini en dehors de la déclaration de classe, la définition de la fonction doit être précédée de la syntaxe template <...>
:
template
type classname::functionname(parameters)
Exemple : L'exemple suivant crée une classe myPair
qui stocke deux objets d'un type donné et fournit une méthode add
pour les additionner :
#include
using namespace std;
template class myPair {
T x, y;
public:
myPair (T first, T second) {
x = first;
y = second;
}
T add () {
T result;
result = x + y;
return result;
}
};
int main() {
myPair intPair(3, 7);
myPair doublePair(3.5, 7.2);
myPair stringPair("Hello", " World!");
cout << intPair.add() << endl;
cout << doublePair.add() << endl;
cout << stringPair.add() << endl;
return 0;
}
La sortie sera :
10
10.7
Hello World!