Polymorphisme de modèle

Question

J'ai récemment reçu un very good answer as how to overload specific class members en dérivant des classes.

La question est maintenant que l'un des membres est en fait basé sur un modèle avec des spécialisations étant soit BaseClass, DerivedClass ou Derived2Class

#include <iostream> 

using std::cin; 
using std::cout; 
using std::endl; 


template<class T> 
class Queue 
{ 
    public: 
     Queue(); 
     Queue(T*); 
} 

class Com 
{ 
    public: 
     virtual void setReady() 
     { 
      cout << "Com" << endl; 
     } 
}; 

class DerivedCom : public Com 
{ 
    public: 
     void setReady() 
     { 
      cout << "DCom" << endl; 
     } 
}; 

class Derived2Com : public Com 
{ 
    public: 
     void setReady() 
     { 
      cout << "D2Com" << endl; 
     } 
}; 

class BaseClass 
{ 
    protected: 
     Com* com; 
     Queue<BaseClass>* queue; 

    public: 
     BaseClass(Com* c = new Com, Queue<BaseClass>* q = new Queue<BaseClass>) : com(c), queue(q) 
     { 
     } 

     void setReady() 
     { 
      com->setReady(); 
     } 
}; 

class DerivedClass : public BaseClass 
{ 
    public: 
     DerivedClass() : BaseClass(new DerivedCom, new Queue<DerivedClass>) 
     { 
     } 
}; 

class Derived2Class : public BaseClass 
{ 
    public: 
     Derived2Class() : BaseClass(new Derived2Com, new Queue<Derived2Class>) 
     {} 
}; 

int main() 
{ 
    BaseClass* base = new Derived2Class(); 

    base->setReady(); 
    return 0; 
} 

je peux, sans problème, les classes simples « surcharge » comme Com, DerivedCom et Derived2Com mais la signature du constructeur de BaseClass ne correspondra pas au type que les classes dérivantes essaient de lui envoyer.

Answer 1

Au lieu de Queue<BaseClass>* queue; vous devriez avoir Queue<BaseClass*> queue; ou, mieux encore, Queue<std::unique_ptr<BaseClass>> et l'initialiser uniquement dans le constructeur de base:

BaseClass(Com* c = new Com, Queue<BaseClass*> q = Queue<BaseClass*>()) : com(c), queue(q) 
{ 
} 

Cependant, avoir la BaseClass tenir une collection d'elle-même en tant que membre est une odeur de code. Je repenserais cette partie.

La raison pour laquelle cela ne fonctionne pas est que Queue<BaseClass> et Queue<DerivedClass> sont classes complètement différentes.

Answer 2

Vous auriez dû Queue<BaseClass*>* queue = new Queue<BaseClass*>(); Ceci déclare un pointeur de file d'attente du pointeur de type BaseClass sur le tas et vous permet d'utiliser la notation de pointeur que vous avez mentionné ci-dessus queue->push(&BaseClass::setReady); et comme ...

Answer 3

Après an answer found elsewhere I changé le concept de classe Queue pour être sans modèle.