Maîtriser les templates de classe en C++ : Guide pratique

Maîtriser les templates de classe en C++ : Guide pratique

Apprenez à exploiter les templates de classe C++ pour écrire du code flexible, agnostique au type, avec des exemples clairs et réels.

Les templates sont une pierre angulaire de la programmation générique en C++. Ils vous permettent de créer des composants réutilisables qui fonctionnent avec n'importe quel type de données, améliorant la clarté du code et réduisant la duplication. C++ offre deux types de templates : les templates de fonction et les templates de classe.

• Templates de fonction
• Templates de classe

Les templates de classe vous permettent de définir une seule classe qui s'adapte à plusieurs types de données. Cela raccourcit non seulement votre code mais le rend aussi plus facile à maintenir.

---

Déclaration d'un template de classe

Un template de classe commence avec le mot-clé template, suivi d'une liste de paramètres de template entre crochets. Vient ensuite la définition réelle de la classe.

template <class T>
class MyClass {
private:
    T var;
public:
    T getVar() const;
};

Ici, T est un placeholder pour le type de données qui sera fourni quand le template sera instancié. Le mot-clé class peut être remplacé par typename sans changer la sémantique.

---

Instanciation d'un template de classe

Une fois un template défini, vous pouvez créer des objets en spécifiant le type désiré :

MyClass<int> intObj;
MyClass<float> floatObj;
MyClass<std::string> stringObj;

Chaque instanciation génère une classe concrète adaptée au type spécifié lors de la compilation.

---

Exemple 1 : Wrapper de nombre générique

#include <iostream>
using namespace std;

// Template de classe qui stocke une valeur unique de n'importe quel type
template <class T>
class Number {
private:
    T value;
public:
    Number(T v) : value(v) {}
    T getValue() const {
        return value;
    }
};

int main() {
    Number<int> intNum(7);
    Number<double> doubleNum(7.7);
    cout << "int Number = " << intNum.getValue() << endl;
    cout << "double Number = " << doubleNum.getValue() << endl;
    return 0;
}

Sortie

int Number = 7 double Number = 7.7

Remarquez que le paramètre de template T est utilisé pour la variable membre, l'argument du constructeur et le type de retour, permettant à la classe de fonctionner avec n'importe quel type.

---

Définition des membres en dehors de la classe

Quand une fonction membre est volumineuse ou partagée entre les spécialisations, vous pouvez la définir en dehors du corps de la classe :

template <class T>
class Sample {
public:
    T identity();
};

// Définition en dehors
template <class T>
T Sample<T>::identity() {
    return static_cast<T>(1);
}

Notez la répétition de la déclaration template<class T> avant la définition hors classe.

---

Exemple 2 : Calculatrice utilisant les templates de classe

#include <iostream>
using namespace std;

template <class T>
class Calculator {
private:
    T a, b;
public:
    Calculator(T x, T y) : a(x), b(y) {}
    T add() const { return a + b; }
    T subtract() const { return a - b; }
    T multiply() const { return a * b; }
    T divide() const { return a / b; }
    void display() const {
        cout << "a: " << a << ", b: " << b << endl;
        cout << "a + b = " << add() << endl;
        cout << "a - b = " << subtract() << endl;
        cout << "a * b = " << multiply() << endl;
        cout << "a / b = " << divide() << endl;
    }
};

int main() {
    Calculator<int> intCalc(2, 1);
    Calculator<float> floatCalc(2.4f, 1.2f);
    cout << "Résultats int :\n";
    intCalc.display();
    cout << "\nRésultats float :\n";
    floatCalc.display();
    return 0;
}

Sortie

Résultats int:
a: 2, b: 1
a + b = 3
a - b = 1
a * b = 2
a / b = 2
Résultats float:
a: 2.4, b: 1.2
a + b = 3.6
a - b = 1.2
a * b = 2.88
a / b = 2

---

Templates avec plusieurs paramètres

Les templates de classe peuvent accepter plus d'un paramètre, et vous pouvez même fournir des types par défaut :

template <class T, class U, class V = int>
class MultiParam {
    T first;
    U second;
    V third;
};

---

Exemple 3 : Template multi-paramètres

#include <iostream>
using namespace std;

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) {}
    void print() const {
        cout << "var1 = " << var1 << endl;
        cout << "var2 = " << var2 << endl;
        cout << "var3 = " << var3 << endl;
    }
};

int main() {
    ClassTemplate<int, double> obj1(7, 7.7, 'c');
    cout << "valeurs obj1 :\n";
    obj1.print();
    ClassTemplate<double, char, bool> obj2(8.8, 'a', false);
    cout << "\nvaleurs obj2 :\n";
    obj2.print();
    return 0;
}

Sortie

valeurs obj1:
var1 = 7
var2 = 7.7
var3 = c
valeurs obj2:
var1 = 8.8
var2 = a
var3 = 0

Dans cet exemple, le troisième paramètre de template prend par défaut char, mais peut être redéfini comme montré avec bool dans obj2.

Spécialisation de template

Vous pouvez fournir une implémentation spécifique pour un type particulier :

template <>
class Number<bool> {
    // Implémentation spécialisée pour bool
};