Introduction
Les templates en C++ offrent une méthode puissante pour créer des fonctions et des classes génériques qui peuvent fonctionner avec différents types de données. Contrairement à la surcharge de fonctions, qui nécessite de définir plusieurs versions d'une fonction pour différents types, un template permet de n'écrire qu'une seule version.
Cet article explore les bases des templates, leurs usages, et des exemples pratiques pour les utiliser efficacement dans vos projets C++.
1. Les templates de fonctions
Un template de fonction permet de définir une seule fonction qui fonctionne avec plusieurs types de données. Le type est déterminé automatiquement par le compilateur lors de l’appel de la fonction.
Syntaxe de base :
template <typename T>
T addition(T a, T b) {
return a + b;
}
Exemple :
#include <iostream>
using namespace std;
template <typename T>
T addition(T a, T b) {
return a + b;
}
int main() {
cout << "Addition de deux entiers : " << addition(5, 3) << endl; // Affiche 8
cout << "Addition de deux flottants : " << addition(2.5, 3.1) << endl; // Affiche 5.6
return 0;
}
Points clés :
- Le mot-clé template est utilisé pour définir un template de fonction.
- typename (ou class, interchangeable) est suivi d'un nom de type générique, ici T.
- Le compilateur déduit automatiquement le type T lors de l'appel.
2. Les templates de classes
Un template de classe permet de créer une classe générique qui fonctionne avec différents types. Cela est particulièrement utile pour des structures de données comme les listes, les piles, ou les files.
Syntaxe de base :
template <typename T>
class Boite {
private:
T contenu;
public:
Boite(T c) : contenu(c) {}
void afficher() {
cout << "Contenu : " << contenu << endl;
}
};
Exemple :
#include <iostream>
using namespace std;
template <typename T>
class Boite {
private:
T contenu;
public:
Boite(T c) : contenu(c) {}
void afficher() {
cout << "Contenu : " << contenu << endl;
}
};
int main() {
Boite<int> boiteEntier(10);
Boite<string> boiteTexte("Bonjour");
boiteEntier.afficher(); // Affiche : Contenu : 10
boiteTexte.afficher(); // Affiche : Contenu : Bonjour
return 0;
}
Points clés :
- Le template est défini avec template avant la déclaration de la classe.
- Lors de l’instanciation de la classe, vous spécifiez le type concret, par exemple Boite.
- Les templates de classe permettent d’écrire des structures génériques comme les conteneurs.
3. Templates avec plusieurs types
Vous pouvez également définir des templates prenant plusieurs types en paramètre.
Exemple :
#include <iostream>
using namespace std;
template <typename T1, typename T2>
class Paire {
private:
T1 premier;
T2 second;
public:
Paire(T1 p, T2 s) : premier(p), second(s) {}
void afficher() {
cout << "Premier : " << premier << ", Second : " << second << endl;
}
};
int main() {
Paire<int, string> paire(1, "Un");
Paire<float, bool> autrePaire(3.14, true);
paire.afficher(); // Affiche : Premier : 1, Second : Un
autrePaire.afficher(); // Affiche : Premier : 3.14, Second : 1
return 0;
}
4. Templates et spécialisation
Dans certains cas, vous souhaitez traiter un type spécifique différemment tout en utilisant des templates. Cela s'appelle la spécialisation de templates.
Exemple :
#include <iostream>
using namespace std;
template <typename T>
class Afficheur {
public:
void afficher(T valeur) {
cout << "Valeur : " << valeur << endl;
}
};
// Spécialisation pour les chaînes
template <>
class Afficheur<string> {
public:
void afficher(string valeur) {
cout << "Texte : " << valeur << endl;
}
};
int main() {
Afficheur<int> entier;
Afficheur<string> texte;
entier.afficher(42); // Affiche : Valeur : 42
texte.afficher("Bonjour"); // Affiche : Texte : Bonjour
return 0;
}
Points clés :
- La spécialisation permet de fournir une implémentation spécifique pour un type particulier.
- Utilisez template <> pour indiquer une spécialisation.
5. Avantages des templates
- Réduction du code redondant : Une seule fonction ou classe peut fonctionner avec plusieurs types.
- Performance : Le code généré par le compilateur est optimisé pour chaque type utilisé.
- Flexibilité : Permet d'écrire du code générique qui s'adapte à divers cas d'usage.
6. Exercice pratique
Énoncé :
- Créez une classe template
Pilepour simuler une pile (structure LIFO). - Implémentez des méthodes pour :
- Empiler un élément (
push). - Dépiler un élément (
pop). - Afficher l’état de la pile.
- Empiler un élément (
- Testez votre classe avec différents types (entiers, chaînes).
Conclusion
Les templates en C++ permettent de généraliser vos fonctions et classes, réduisant ainsi la duplication de code tout en rendant votre programme plus flexible. Ils sont particulièrement utiles dans les bibliothèques comme la STL (std::vector, std::map, etc.) et dans les projets complexes nécessitant des structures de données personnalisées.
Pour découvrir les conteneurs et algorithmes fournis par la STL, consultez notre article : Introduction à la STL en C++.
- Consultez notre article sur les bases de la programmation orientée objet pour mieux comprendre les concepts sous-jacents.
- Découvrez comment les vecteurs et tableaux interagissent avec les templates.
A propos de pointerlab
PointerLab est une ESN spécialisée dans le développement de logiciels C++ et experte sur le framework Qt.
Le nom PointerLab reflète à la fois notre expertise technique et notre philosophie. Inspiré des pointeurs en C++, il illustre notre maîtrise du langage et notre capacité à manipuler des concepts complexes avec précision et rigueur. Le terme "Lab" met en avant notre volonté d'expérimentation et d'innovation pour trouver les meilleures solutions pour nos clients.
Nous défendons des valeurs d'excellence technique, de transparence, et de redistribution juste. Chez PointerLab, nous construisons une société de conseil horizontale, où l'humain est au centre, et où chaque projet est mené avec passion et expertise.