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 dans laquelle une classe hérite d’une classe de base modèle en se transmettant elle-même comme argument du modèle. Cela permet le polymorphisme à la compilation et autorise les classes de base à accéder aux membres de la classe dérivée sans 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";
    }
};

CRTP est particulièrement puissant pour créer des mixins : des fonctionnalités réutilisables qui peuvent être « mélangées » aux 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();  // Sortie : Person: Alice

Le principal avantage est que tous les appels de méthode sont résolus au moment de la compilation, ce qui élimine 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 au moment de 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 la surcharge des fonctions virtuelles. Vous créerez deux mixins pouvant être « mélangés » à n’importe quelle classe : l’un pour compter les instances et l’autre pour générer des représentations sous forme de chaîne.

Vous organiserez votre code sur trois fichiers :

Mixins.h : Définissez deux modèles de mixins 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 posséder un compteur statique qui est incrémenté dans le constructeur et décrémenté dans le destructeur. Fournissez une méthode statique getCount() qui renvoie le compteur 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 lors 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 suivant : Player: [name] (Level [level])

Créez une classe Enemy qui hérite également des deux mixins. Elle doit stocker un type et des points de vie, 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 distincte) :
1. Nom du Player (chaîne)
2. Niveau du Player (entier)
3. Type de l’Enemy (chaîne)
4. Points de vie de l’Enemy (entier)
Créez un Player et un Enemy avec les valeurs fournies. Montrez ensuite les mixins :
1. Affichez Player count: [count] en utilisant la méthode statique getCount()
2. Affichez Enemy count: [count]
3. Appelez describe() sur le Player
4. Appelez describe() sur l’Enemy
5. Créez un second Player avec le nom "Guest" et le niveau 1
6. Affichez à nouveau Player count: [count] pour montrer le compteur mis à jour
7. Appelez describe() sur le second Player

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 montre comment les mixins CRTP ajoutent des fonctionnalités (comptage et description) à des classes sans lien entre elles, 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 mixins, mais chacun conserve son propre compteur d’instances, car le modèle est instancié avec des types différents.

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;
}