1. Le paradigme de la programmation générique

Considérons le besoin fréquent d'implémenter une routine pour permuter deux variables. Sans mécanisme avancé, le développeur est contraint de surcharger la fonction pour chaque type de données :

void Permute(int& gauche, int& droite)
{
    int tmp = gauche;
    gauche = droite;
    droite = tmp;
}
void Permute(double& gauche, double& droite)
{
    double tmp = gauche;
    gauche = droite;
    droite = tmp;
}
void Permute(char& gauche, char& droite)
{
    char tmp = gauche;
    gauche = droite;
    droite = tmp;
}
// ... répétition infinie pour chaque nouveau type

Si la surcharge résout temporairement le problème, elle introduit rapidement deux inconvénients majeurs :

• Redondance structurelle : Chaque nouvelle structure exige une implémentation spécifique, réduisant drastiquement la réutilisabilité du code.
• Fragilité de la maintenance : Une correction logique dans un bloc impose de répéter cette modification dans l'ensemble des surcharges, augmentant les risques d'erreurs.

La solution réside dans la capacité à fournir au compilateur un schéma directeur. Ce mécanisme, appelé programmation générique, consiste à écrire du code indépendant du type. Les templates C++ constituent l'outil fondamental de cette approche, permettant au compilateur de synthétiser automatiquement les spécialisations nécessaires.

2. Templates de fonctions

2.1 Définition et syntaxe

Un template de fonction agit comme un générateur abstrait. Il ne constitue pas une fonction exécutable à part entière, mais plutôt une spécification qui sera paramétrée lors de l'utilisasion pour produire une version concrète adoptée aux arguments passés.

template <typename DataType>
void EchangerValeurs(DataType& premier, DataType& second)
{
    DataType tampon = premier;
    premier = second;
    second = tampon;
}

Le mot-clé typename déclare le paramètre générique. Il est totalement interchangeable avec class dans ce contexte. Notez bien que struct n'est pas une alternative valide pour déclarer un paramètre template.

2.2 Mécanisme de compilation

Contrairement à une fonction classique, le template n'existe pas directement dans le binaire final. Il sert de moule au compilateur. Pendant la phase de compilation, l'analyseur examine les types des arguemnts réels et instancie dynamiquement le code machine correspondant. Par exemple, un appel avec des double déclenchera la génération d'une routine spécialisée pour ce type, exactement comme le ferait un appel avec des char. La lourdeur de la répétition manuelle est ainsi transférée au compilateur.

2.3 Instanciation du template

L'instanciation correspond à la création effective de la fonction spécialisée. Deux approches sont possibles selon le contexte :

Instanciation implicite

Le compilateur déduit le type T directement depuis les arguments :

template <typename T>
T CalculerSomme(const T& a, const T& b)
{
    return a + b;
}

int main()
{
    int val1 = 5, val2 = 10;
    double val3 = 5.5, val4 = 10.2;

    CalculerSomme(val1, val2); // T déduit automatiquement comme int
    CalculerSomme(val3, val4); // T déduit automatiquement comme double

    // CalculerSomme(val1, val3); // Erreur de compilation : le compilateur ne peut pas unifier T en int et double
    // Les templates n'effectuent aucune conversion automatique de type.
    CalculerSomme(val1, static_cast<int>(val3)); // Conversion manuelle imposée par le développeur
    return 0;
}

Instanciation explicite

On impose le type entre chevrons lors de l'appel. Cette méthode est indispensable lorsque la déduction échoue :

int main()
{
    int entier = 5;
    double reel = 10.5;

    CalculerSomme<int>(entier, reel); // Force l'instanciation avec int, convertissant implicitement reel

    template <typename T>
    T* AllouerMemoire(std::size_t taille)
    {
        return new T[taille];
    }

    // AllouerMemoire(10); // Impossible de déduire T depuis un entier
    int* ptr = AllouerMemoire<int>(10); // Instanciation explicite requise car T n'apparaît pas dans la signature déductible
    return 0;
}

2.4 Règles de résolution d'appel

Lorsqu'un template coexiste avec une fonction ordinaire de même nom, le compilateur applique des priorités strictes pour choisir la cible :

1. Correspondance exacte avec une fonction native : Si les arguments correspondent parfaitement à une fonction non-template, celle-ci est systématiquement privilégiée.
2. Meilleure adaptation : Si la fonction native exige des conversions, mais que le template peut générer une signature parfaitement alignée, le template sera choisi.
3. Absence de conversions implicites : Les templates exigent une correspondance stricte des types, contrairement aux fonctions classiques qui tolèrent certaines promotions automatiques.

// Version spécialisée pour les entiers
int Additionner(int x, int y) { return x + y; }

// Version générique
template <typename T1, typename T2>
T1 Additionner(T1 x, T2 y) { return x + y; }

void TestResolutions()
{
    Additionner(4, 7);      // Appelle la version native (match exact, pas de spécialisation nécessaire)
    Additionner(4, 7.0);    // Appelle le template (génère une version spécialisée int, double)
}

3. Templates de classes

3.1 Déclaration et structure

Le principe s'étend naturellement aux classes. Avant les templates, créer un conteneur adaptable nécessitait de dupliquer l'entière classe pour chaque type de données. Le template résout ce verrou en centralisant la logique :

template <typename Element>
class PileGenerique
{
public:
    PileGenerique(std::size_t capaciteInit = 4)
        : _donnees(new Element[capaciteInit]), _compteur(0), _limite(capaciteInit)
    {}

    void Empiler(const Element& charge)
    {
        // Vérification de capacité omise pour concision
        _donnees[_compteur++] = charge;
    }

    ~PileGenerique();

private:
    Element* _donnees;
    std::size_t _compteur;
    std::size_t _limite;
};

Pour définir un membre en dehors de la classe, la liste des paramètres templates doit être reprise explicitement avant la signature :

template <typename Element>
PileGenerique<Element>::~PileGenerique()
{
    delete[] _donnees;
    _donnees = nullptr;
    _compteur = _limite = 0;
}

3.2 Instanciation et contraintes de compilation

Contrairement aux fonctions, une classe template ne peut jamais être instanciée implicitement. Le type doit toujours être spécifié explicitement par le développeur :

PileGenerique<int> pileEntiers;
PileGenerique<double> pileReels;

pileEntiers.Empiler(42);
pileReels.Empiler(3.14);

Une contrainte technique fondamentale régit les templates de classes : en raison du modèle de compilation séparée du C++, les définitions complètes des membres doivent résider dans le fichier d'en-tête (.hpp ou .h). Il est impossible de séparer la déclaration et l'implémentation dans des fichiers .cpp distincts, car le compilateur doit avoir accès au corps complet du template au moment de l'instanciation pour synthétiser le code approprié. Séparer la déclaration et la définition entraînera systématiquement des erreurs de résolution de symbole en phase de liaison.