Un template (patron) C++ permet de définir des fonctions et des classes génériques, indépendantes d'un type de données particulier. C'est le fondement de la programmation générique en C++.
Un template est un patron paramétré par un ou plusieurs types génériques (T). Le compilateur génère automatiquement une version spécialisée pour chaque type utilisé — c'est l'instanciation du template, réalisée à la compilation.
C++ utilise template pour déclarer un patron, et typename (ou class, interchangeable ici) pour nommer le paramètre de type générique.
Fonction template
Une fonction template peut fonctionner avec différents types de données. Elle remplace avantageusement la surcharge de fonctions pour des logiques identiques.
template <class T> // ou template <typename T>
type_retour nomFonction(T p1) {
...
}Exemple n°1 — Somme de deux valeurs du même type
#include <iostream>
using namespace std;
template <class T>
T somme(T v1, T v2) { return v1 + v2; }
int main() {
cout << somme(5, 2) << endl; // int
cout << somme(3.5, 2.75) << endl; // double
return 0;
}Exemple n°2 — Maximum générique
template <class T>
T maxi(T n1, T n2) { return (n1 > n2) ? n1 : n2; }
int main() {
cout << maxi(5, 2) << endl; // int : 5
cout << maxi(3.5, 2.75) << endl; // double : 3.5
cout << maxi('Z', 'M') << endl; // char : Z
return 0;
}Exemple n°3 — Deux paramètres de types différents
template <class T1, class T2>
void afficher(T1 n1, T2 n2) {
cout << n1 << endl;
cout << n2 << endl;
}
int main() {
afficher(2, 'A');
afficher(3.75, 'Z');
afficher(7.5, 8);
return 0;
}Classe template
Une classe template définit une structure générique paramétrée par un ou plusieurs types. Elle est utile pour implémenter des structures de données comme LinkedList, Stack, Queue, Array, etc.
template <class T>
class nomClasse {
public:
T attr;
T nomFonction(T arg);
};
// Instanciation
nomClasse<int> obj1;
nomClasse<float> obj2;
nomClasse<string> obj3; Exemple n°5 — Classe Tableau générique
#include <iostream>
using namespace std;
template <class T>
class Tableau {
private:
T *tab;
int taille;
public:
Tableau(T t[], int n);
void afficher();
};
template <class T>
Tableau<T>::Tableau(T t[], int n) {
tab = new T[n];
taille = n;
for(int i = 0; i < taille; i++) tab[i] = t[i];
}
template <class T>
void Tableau<T>::afficher() {
for (int i = 0; i < taille; i++) cout << " " << *(tab + i);
cout << endl;
}
int main() {
int t[5] = {1, 2, 3, 4, 5};
Tableau<int> obj(t, 5);
obj.afficher();
return 0;
}Questions fréquentes sur les templates
| Question | Réponse |
|---|---|
| Peut-on avoir des arguments de type par défaut ? | Oui : template<class T, class U = char> |
| Que se passe-t-il avec un membre statique ? | Chaque instanciation du template possède sa propre variable statique |
| Peut-on passer des paramètres non typés ? | Oui (ex. : template<class T, int max>), mais la valeur doit être une constante connue à la compilation |
Un paramètre non typé doit être une constante — le compilateur en a besoin au moment de la compilation pour générer le code. Passer une variable ordinaire provoquera une erreur de compilation.
template <class T, int max>
int mini(T tab[], int n) {
int m = max;
for (int i = 0; i < n; i++) if (tab[i] < m) m = tab[i];
return m;
}
int main() {
int t1[] = {750, 30, 11, 18};
cout << mini<int, 10000>(t1, 4) << endl; // OK : 10000 est une constante
// mini<int, maxi>(t2, n2); // ERREUR : maxi est une variable
return 0;
}
Discussion (0)
Soyez le premier à laisser un commentaire !
Laisser un commentaire
Votre commentaire sera visible après modération.