Maîtriser les templates C++ : Guide de la programmation générique

Les templates sont la fondation de la programmation générique, qui consiste à écrire du code d'une manière indépendante de tout type particulier.

Un template est un plan ou une formule pour créer une classe générique ou une fonction. Les conteneurs de bibliothèque comme les itérateurs et les algorithmes sont des exemples de programmation générique et ont été développés en utilisant le concept de template.

Il y a une seule définition de chaque conteneur, comme vector, mais nous pouvons définir de nombreux types différents de vecteurs, par exemple vector<int> ou vector<string>.

Vous pouvez utiliser les templates pour définir des fonctions aussi bien que des classes, voyons comment ils fonctionnent :

Template de fonction

La forme générale d'une définition de fonction template est montrée ici :

template <class type> type_retour nom_fonction(liste_paramètres) {
    // corps de la fonction
}

Ici, type est un nom de placeholder pour un type de données utilisé par la fonction. Ce nom peut être utilisé dans la définition de la fonction.

Voici l'exemple d'un template de fonction qui retourne le maximum de deux valeurs :

#include <iostream>
#include <string>
using namespace std;

template <typename T>
inline T const& Max(T const& a, T const& b) {
    return a < b ? b : a;
}

int main() {
    int i = 39;
    int j = 20;
    cout << "Max(i, j) : " << Max(i, j) << endl;
    double f1 = 13.5;
    double f2 = 20.7;
    cout << "Max(f1, f2) : " << Max(f1, f2) << endl;
    string s1 = "Hello";
    string s2 = "World";
    cout << "Max(s1, s2) : " << Max(s1, s2) << endl;
    return 0;
}

Si nous compilons et exécutons le code ci-dessus, cela produirait le résultat suivant :

Max(i, j) : 39
Max(f1, f2) : 20.7
Max(s1, s2) : World

Template de classe

Tout comme nous pouvons définir des templates de fonction, nous pouvons aussi définir des templates de classe. La forme générale d'une déclaration de classe générique est montrée ici :

template <class type> class nom_classe {
    . . .
}

Ici, type est le nom du type placeholder, qui sera spécifié quand une classe est instanciée. Vous pouvez définir plus d'un type de données générique en utilisant une liste séparée par des virgules.

Voici l'exemple pour définir la classe Stack<> et implémenter des méthodes génériques pour pousser et dépiler les éléments de la pile :

#include <iostream>
#include <vector>
#include <cstdlib>
#include <string>
#include <stdexcept>
using namespace std;

template <class T>
class Stack {
private:
    vector<T> elems; // éléments
public:
    void push(T const&); // empiler élément
    void pop(); // dépiler élément
    T top() const; // retourner élément du sommet
    bool empty() const { // retourner true si vide
        return elems.empty();
    }
};

template <class T>
void Stack<T>::push(T const& elem) {
    // ajouter copie de l'élément passé
    elems.push_back(elem);
}

template <class T>
void Stack<T>::pop() {
    if(elems.empty()) {
        throw out_of_range("Stack<>::pop() : pile vide");
    }
    // supprimer dernier élément
    elems.pop_back();
}

template <class T>
T Stack<T>::top() const {
    if(elems.empty()) {
        throw out_of_range("Stack<>::top() : pile vide");
    }
    // retourner copie du dernier élément
    return elems.back();
}

int main() {
    try {
        Stack<int> intStack; // pile d'entiers
        Stack<string> stringStack; // pile de chaînes
        // manipuler pile d'entiers
        intStack.push(7);
        cout << intStack.top() << endl;
        // manipuler pile de chaînes
        stringStack.push("hello");
        cout << stringStack.top() << std::endl;
        stringStack.pop();
        stringStack.pop();
    } catch(exception const& ex) {
        cerr << "Exception : " << ex.what() << endl;
        return -1;
    }
}

Si nous compilons et exécutons le code ci-dessus, cela produirait le résultat suivant :

7
hello
Exception : Stack<>::pop() : pile vide