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 generic 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 generic pour tout le reste.

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

// Template 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 fonction 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 plutôt que le modèle générique.

Défi

Facile

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

Vous allez créer deux fichiers pour organiser votre code de template :

Formatter.h : Définissez un template de classe appelé Formatter qui formate les valeurs pour l'affichage. Votre template générique doit fonctionner avec n'importe quel type, mais vous créerez également des versions spécialisées pour les types qui nécessitent un traitement personnalisé.
Le template Formatter primary doit contenir :
- 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 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 :
- La méthode format() doit afficher : String: "<value>"
Créez également un template 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 distincte) :
1. Un entier
2. Un nombre double
3. Un booléen sous forme de chaîne (true ou false)
4. Une valeur de type chaîne
Démontrez le fonctionnement de vos formateurs en créant des objets Formatter appropriés et en appelant format() pour chaque type :
1. Formatez l'entier avec Formatter<int>
2. Formatez le nombre double avec Formatter<double>
3. Formatez le booléen avec Formatter<bool> (convertissez d'abord l'entrée chaîne en booléen)
4. Formatez la chaîne avec Formatter<const char*>
Démontrez ensuite la spécialisation du template 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 template générique traite les entiers et les nombres 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.

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
    // Indice : Utiliser strVal.c_str() pour obtenir const char*
    
    // TODO: Appeler formatPair avec deux entiers : 10 et 20
    
    // TODO: Appeler formatPair avec deux chaînes C : "hello" et "world"
    
    return 0;
}