Mixins via CRTP

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

Le Curiously Recurring Template Pattern (CRTP) est une technique par laquelle une classe hérite d'une classe de base template, en se passant elle-même comme argument de template. Cela permet un polymorphisme à la compilation et autorise les classes de base à accéder aux membres de la classe dérivée sans utiliser de fonctions virtuelles.

La structure de base du CRTP ressemble à ceci :

template <typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class MyClass : public Base<MyClass> {
public:
    void implementation() {
        std::cout << "MyClass implementation\n";
    }
};

Le CRTP est particulièrement puissant pour créer des mixins - des fonctionnalités réutilisables qui peuvent être « mélangées » à des classes. Contrairement à l'héritage traditionnel, les mixins ajoutent des capacités sans créer de hiérarchies profondes :

template <typename Derived>
class Printable {
public:
    void print() const {
        const Derived& self = static_cast<const Derived&>(*this);
        std::cout << self.toString() << "\n";
    }
};

class Person : public Printable<Person> {
    std::string name;
public:
    Person(const std::string& n) : name(n) {}
    std::string toString() const { return "Person: " + name; }
};

// Utilisation :
Person p("Alice");
p.print();  // Résultat : Person: Alice

L'avantage principal est que tous les appels de méthodes sont résolus à la compilation, éliminant le surcoût des fonctions virtuelles. Vous pouvez combiner plusieurs mixins CRTP pour composer des fonctionnalités, ce qui en fait une alternative flexible au polymorphisme à l'exécution lorsque les types sont connus à la compilation.

Défi

Facile

Construisons un système de journalisation qui utilise des mixins CRTP pour ajouter des fonctionnalités réutilisables à différentes classes sans le surcoût des fonctions virtuelles. Vous allez créer deux mixins qui peuvent être "mélangés" à n'importe quelle classe : un pour compter les instances et un pour générer des représentations sous forme de chaîne de caractères.

Vous organiserez votre code sur trois fichiers :

Mixins.h : Définissez deux modèles de mixin CRTP qui fournissent des fonctionnalités réutilisables.
Créez un modèle de mixin Countable qui suit le nombre d'instances d'une classe dérivée existantes. Il doit avoir un compteur statique qui s'incrémente dans le constructeur et se décrémente dans le destructeur. Fournissez une méthode statique getCount() qui renvoie le compte actuel.

Créez un modèle de mixin Describable qui fournit une méthode describe(). Cette méthode doit utiliser static_cast pour accéder à la classe dérivée et appeler sa méthode getDescription(), puis afficher le résultat suivi d'un saut de ligne.

N'oubliez pas que les mixins CRTP utilisent static_cast<Derived*>(this) pour accéder aux membres de la classe dérivée au moment de la compilation.
Entities.h : Définissez deux classes d'entités qui héritent des deux mixins.
Créez une classe Player qui hérite à la fois de Countable<Player> et de Describable<Player>. Elle doit stocker un nom et un niveau, et fournir une méthode getDescription() qui renvoie une chaîne au format : Player: [name] (Level [level])

Créez une classe Enemy qui hérite également des deux mixins. Elle doit stocker un type et une santé, et fournir une méthode getDescription() qui renvoie : Enemy: [type] with [health] HP

N'oubliez pas d'initialiser le compteur statique pour chaque classe.
main.cpp : Lisez quatre entrées (chacune sur une ligne séparée) :
1. Nom du joueur (chaîne de caractères)
2. Niveau du joueur (entier)
3. Type d'ennemi (chaîne de caractères)
4. Santé de l'ennemi (entier)
Créez un Player et un Enemy avec les valeurs données. Ensuite, faites la démonstration des mixins :
1. Affichez Player count: [count] en utilisant la méthode statique getCount()
2. Affichez Enemy count: [count]
3. Appelez describe() sur le joueur
4. Appelez describe() sur l'ennemi
5. Créez un second joueur avec le nom "Guest" et le niveau 1
6. Affichez à nouveau Player count: [count] pour montrer le compte mis à jour
7. Appelez describe() sur le second joueur

Par exemple, avec les entrées Hero, 10, Dragon, et 500 :

Player count: 1
Enemy count: 1
Player: Hero (Level 10)
Enemy: Dragon with 500 HP
Player count: 2
Player: Guest (Level 1)

Ce défi démontre comment les mixins CRTP ajoutent des fonctionnalités (comptage et description) à des classes non liées sans utiliser de fonctions virtuelles. Player et Enemy acquièrent tous deux les mêmes capacités en héritant des mêmes modèles de mixin, mais chacun conserve son propre compteur d'instances distinct car le modèle est instancié avec des types différents.

Aide-mémoire

Le Curiously Recurring Template Pattern (CRTP) permet le polymorphisme à la compilation en faisant hériter une classe d'une classe de base template, en se passant elle-même comme argument de template :

template <typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class MyClass : public Base<MyClass> {
public:
    void implementation() {
        std::cout << "MyClass implementation\n";
    }
};

Les Mixins CRTP fournissent des fonctionnalités réutilisables sans hiérarchies d'héritage profondes :

template <typename Derived>
class Printable {
public:
    void print() const {
        const Derived& self = static_cast<const Derived&>(*this);
        std::cout << self.toString() << "\n";
    }
};

class Person : public Printable<Person> {
    std::string name;
public:
    Person(const std::string& n) : name(n) {}
    std::string toString() const { return "Person: " + name; }
};

Avantages clés :

Tous les appels de méthodes sont résolus à la compilation
Pas de surcoût lié aux fonctions virtuelles
Plusieurs mixins peuvent être combinés pour composer des fonctionnalités
Chaque instanciation de template conserve un état distinct (par exemple, des compteurs statiques séparés par type dérivé)

Essayez vous-même

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

using namespace std;

int main() {
    // Lire les entrées
    string playerName;
    int playerLevel;
    string enemyType;
    int enemyHealth;
    
    cin >> playerName;
    cin >> playerLevel;
    cin >> enemyType;
    cin >> enemyHealth;
    
    // TODO: Créer un Player avec le nom et le niveau donnés
    
    // TODO: Créer un Enemy avec le type et la santé donnés
    
    // TODO: Afficher "Player count: [count]" en utilisant Player::getCount()
    
    // TODO: Afficher "Enemy count: [count]" en utilisant Enemy::getCount()
    
    // TODO: Appeler describe() sur le joueur
    
    // TODO: Appeler describe() sur l'ennemi
    
    // TODO: Créer un second joueur avec le nom "Guest" et le niveau 1
    
    // TODO: Afficher "Player count: [count]" à nouveau
    
    // TODO: Appeler describe() sur le second joueur
    
    return 0;
}