Puis-je utiliser CRTP avec plusieurs classes dérivées et les utiliser de façon polymorphique?

Question

J'ai une telle hiérarchie de classes:

template <class Type> 
class CrtpBase 
{ 
protected: 
    Type& real_this() 
    { 
     return static_cast<Type&>(*this); 
    } 
}; 

template <class ChildType> 
class Base : CrtpBase<ChildType> 
{ 
public: 
    void foo() 
    { 
     this->real_this().boo(); 
    } 
}; 

class Derived1 : public Base<Derived1> 
{ 
public: 
    void boo { ... } 
}; 

class Derived2 : public Base<Derived2> 
{ 
public: 
    void boo { ... } 
}; 

La chose est, je veux utiliser mes cours ainsi:

std::vector<Base*> base_vec; 
base_vec.push_bach(new Derived1()); 
base_vec.push_bach(new Derived2()); 
......... 
base_vec[0]->foo(); 

Mais ce n'est pas possible, parce que la classe de base pour tous les dérivés classes est différent (en fait, Base n'est pas du tout un type, c'est un template). Donc, est-il possible d'utiliser crtp avec plusieurs classes dérivées, avec le polymorphisme?

Answer 1

En effet, il est, vous devez ajouter le non-modèle classe trop de base appropriée:

class AbstractBase 
{ 
public: 
    virtual ~AbstractBase() {} 

    virtual void foo() = 0; 
}; 


template <class ChildType> 
class Base : CrtpBase<ChildType>, public AbstactBase 
{ 
    void foo() override { this->real_this().boo(); } 
}; 

Ensuite, déclarez votre vecteur std::vector<AbstractBase*>. Cela introduit en effet la surcharge de dispatch dynamique (que vous essayiez probablement d'éviter en utilisant CRTP), mais la répartition dynamique est le seul moyen d'obtenir le polymorphisme d'exécution en C++.

Cela peut quand même être bénéfique. Par exemple, si l'implémentation de foo est partagée par toutes les classes dérivées, mais fait appel à de nombreuses fonctions de type boo (chaque classe dérivée ayant une implémentation différente de celles-ci), vous ne paierez le coût de répartition dynamique qu'une seule fois en appelant foo , puis tous les appels effectués au sein defoo sont envoyés statiquement, style CRTP.

D'autre part, si elle est juste un appel à une fonction au sein boo -comme foo, vous pouvez aussi bien faire dans la base virtuelle boo, mettre foo non virtuelle, ainsi se débarrasser de CRTP. Le coût sera le même alors: un envoi non virtuel (foo) et un envoi virtuel (boo).

---

Side note, vous devriez fortement envisager de stocker des pointeurs intelligents dans le std::vector; possédant les pointeurs bruts sont une mauvaise pratique.