Spécialisation de templates

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy — leçon 66 sur 104.

Parfois, un modèle générique ne fonctionne pas bien pour tous les types. Par exemple, comparer des chaînes de caractères de style C avec > compare les adresses des pointeurs, et non le texte réel. La spécialisation de modèle vous permet de fournir une implémentation personnalisée pour des types spécifiques tout en conservant la version générique pour tout le reste.

Une spécialisation complète remplace l'intégralité du template pour un type spécifique. Vous la déclarez avec une liste de paramètres de template vide et spécifiez le type concret :

// Modèle principal
template <typename T>
class Printer {
public:
    void print(T value) {
        std::cout << value << std::endl;
    }
};

// Spécialisation complète pour const char*
template <>
class Printer<const char*> {
public:
    void print(const char* value) {
        std::cout << "String: " << value << std::endl;
    }
};

Printer<int> intPrinter;
intPrinter.print(42);           // Sortie : 42

Printer<const char*> strPrinter;
strPrinter.print("hello");      // Sortie : String: hello

Les modèles de fonctions peuvent également être spécialisés :

template <typename T>
bool isEqual(T a, T b) {
    return a == b;
}

template <>
bool isEqual<const char*>(const char* a, const char* b) {
    return std::strcmp(a, b) == 0;
}

isEqual(5, 5);              // Utilise la version générique
isEqual("hi", "hi");        // Utilise la version spécialisée

Le compilateur préfère toujours la correspondance la plus spécifique - si une spécialisation existe pour le type exact utilisé, elle sera choisie de préférence au modèle générique.

Défi

Facile

Construisons un système de formatage sensible aux types qui démontre comment la spécialisation de modèles vous permet de personnaliser le comportement pour des types spécifiques tout en conservant une solution générique par défaut pour tout le reste.

Vous allez créer deux fichiers pour organiser votre code de modèle :

Formatter.h : Définissez un modèle de classe appelé Formatter qui formate des valeurs pour l'affichage. Votre modèle générique doit fonctionner avec n'importe quel type, mais vous créerez également des versions spécialisées pour les types nécessitant un traitement personnalisé.
Le modèle Formatter principal doit avoir :
- Une méthode format() qui prend une valeur de type T et affiche : Value: <value>
Créez une spécialisation complète pour bool qui affiche un texte lisible par l'homme au lieu de 1 ou 0 :
- La méthode format() doit afficher : Boolean: true ou Boolean: false
Créez une spécialisation complète pour const char* qui ajoute des guillemets autour des chaînes de caractères :
- La méthode format() doit afficher : String: "<value>"
Créez également un modèle de fonction appelé formatPair qui prend deux valeurs du même type et les affiche ensemble sous la forme : Pair: [<first>, <second>]

Créez une spécialisation de formatPair pour const char* qui entoure chaque chaîne de guillemets : Pair: ["<first>", "<second>"]
main.cpp : Lisez quatre entrées (chacune sur une ligne séparée) :
1. Un entier
2. Un double
3. Un booléen sous forme de chaîne ("true" ou "false")
4. Une valeur de chaîne de caractères
Démontrez vos formateurs en créant les objets Formatter appropriés et en appelant format() pour chaque type :
1. Formatez l'entier en utilisant Formatter<int>
2. Formatez le double en utilisant Formatter<double>
3. Formatez le booléen en utilisant Formatter<bool> (convertissez d'abord l'entrée de chaîne en bool)
4. Formatez la chaîne en utilisant Formatter<const char*>
Ensuite, démontrez la spécialisation du modèle de fonction :
1. Appelez formatPair avec deux entiers : 10 et 20
2. Appelez formatPair avec deux chaînes C : "hello" et "world"

Par exemple, avec les entrées 42, 3.14, true, et Hello :

Value: 42
Value: 3.14
Boolean: true
String: "Hello"
Pair: [10, 20]
Pair: ["hello", "world"]

Remarquez comment le modèle générique gère les entiers et les doubles de manière identique, tandis que les versions spécialisées pour bool et const char* fournissent un formatage personnalisé. Le compilateur sélectionne automatiquement la correspondance la plus spécifique pour chaque type que vous utilisez.

Aide-mémoire

La spécialisation de modèle vous permet de fournir des implémentations personnalisées pour des types spécifiques tout en conservant une version générique pour tous les autres types.

Syntaxe de la spécialisation complète

Déclarez une spécialisation avec une liste de paramètres de modèle vide template <> et spécifiez le type concret :

// Modèle primaire
template <typename T>
class Printer {
public:
    void print(T value) {
        std::cout << value << std::endl;
    }
};

// Spécialisation complète pour const char*
template <>
class Printer<const char*> {
public:
    void print(const char* value) {
        std::cout << "String: " << value << std::endl;
    }
};

Spécialisation de modèle de fonction

Les modèles de fonctions peuvent également être spécialisés :

template <typename T>
bool isEqual(T a, T b) {
    return a == b;
}

template <>
bool isEqual<const char*>(const char* a, const char* b) {
    return std::strcmp(a, b) == 0;
}

Sélection du compilateur

Le compilateur préfère toujours la correspondance la plus spécifique - si une spécialisation existe pour le type exact utilisé, elle sera choisie au détriment du modèle générique.

Essayez vous-même

#include <iostream>
#include <string>
#include "Formatter.h"

using namespace std;

int main() {
    // Lire les entrées
    int intVal;
    double doubleVal;
    string boolStr;
    string strVal;
    
    cin >> intVal;
    cin >> doubleVal;
    cin >> boolStr;
    cin >> strVal;
    
    // Convertir la chaîne en bool
    bool boolVal = (boolStr == "true");
    
    // TODO: Créer Formatter<int> et formater l'entier
    
    // TODO: Créer Formatter<double> et formater le double
    
    // TODO: Créer Formatter<bool> et formater le booléen
    
    // TODO: Créer Formatter<const char*> et formater la chaîne
    // Hint: Utiliser strVal.c_str() pour obtenir const char*
    
    // TODO: Appeler formatPair avec deux entiers : 10 et 20
    
    // TODO: Appeler formatPair avec deux C-strings : "hello" et "world"
    
    return 0;
}