Comment s'appelle l'idiome du polymorphisme statique en C++?

Modèle de template curieusement récurrent (CRTP), également connu sous le nom de polymorphisme statique ou polymorphisme en temps de compilation.

Le principe du CRTP repose sur le fait que la classe template Base utilise elle-même comme paramètre de template, étant en même temps la classe de base pour une classe dérivée Derived.

template <typename T>
class Base
{
public:
    void interfaceMethod()
    {
        // Appel statique à la méthode 'implementationMethod'
        // sur un objet de type Derived (qui est T)
        static_cast<T*>(this)->implementationMethod();
    }

    // Pas besoin d'une méthode virtuelle ici
};

class Derived : public Base<Derived>
{
public:
    void implementationMethod()
    {
        // Implémentation spécifique pour Derived
        // ...
    }
};

Avantages du CRTP par rapport au polymorphisme dynamique (avec fonctions virtuelles):

• Performance: Les appels de fonctions sont statiques et résolus en temps de compilation, évitant les coûts supplémentaires de la table virtuelle.
• Absence de coûts supplémentaires pour les fonctions virtuelles: Il n'est pas nécessaire de stocker ou d'utiliser vptr/vtbl.
• Typage plus strict: Les erreurs liées à des incompatibilités de types ou à l'absence d'implémentation sont détectées à la compilation.

Inconvénients:

• Nécessité de connaître le type du descendant: La classe de base doit être une template et "savoir" le type de la classe dérivée.
• Complexité pour les débutants: Le pattern peut être moins intuitif comparé à l'héritage classique avec fonctions virtuelles.
• Impossibilité de travailler avec une collection de différents types CRTP: On ne peut pas stocker dans un conteneur des objets de différentes classes dérivées CRTP et les appeler via un pointeur ou une référence de base.

Comparaison avec le polymorphisme dynamique:

Aspect	CRTP (polymorphisme statique)	Polymorphisme dynamique (fonctions virtuelles)
Résolution d'appel	En temps de compilation	En temps d'exécution
Performance	Plus élevé (pas de coûts vtbl)	Moins élevé (coûts vtbl présents)
Coûts supplémentaires	Pas de vptr/vtbl	Avec vptr/vtbl
Flexibilité (collections)	Non (impossible de travailler avec des types hétérogènes via un pointeur/enlaceur de base commun)	Oui (possible de travailler avec des types hétérogènes)
Détection d'erreurs	En temps de compilation	En temps d'exécution
Complexité	Plus élevé pour les débutants	Moins élevé pour les débutants