Un pointeur vers la classe de base du modèle abstrait?

Question

Je ne peux pas comprendre cela. Je dois avoir une classe de base de modèle abstrait, qui est la suivante:

template <class T> class Dendrite 
{ 
    public: 
     Dendrite() 
     { 
     } 

     virtual ~Dendrite() 
     { 
     } 

     virtual void Get(std::vector<T> &o) = 0; 

    protected: 
     std::vector<T> _data; 
}; 

Maintenant, je Déduire de ce qui spécifie l'utilisation exacte de Dendrite.

Maintenant le problème.

Comment créer un vecteur de pointeurs vers la classe de base sans type spécifique, que je souhaite spécifier en y poussant des éléments plus tard? Quelque chose comme:

class Foo 
{ 
    public: 
     ... 

    private: 
     std::vector<Dendrite *> _inputs; //!< Unfortunately, this doesn't work... 

     //! Now I could later on push elements to this vector like 
     //! 
     //! _inputs.push_back(new DeriveFromDendrite<double>()) and 
     //! _inputs.push_back(new DeriveFromDendrite<int>()). 
}; 

Est-ce possible ou manque-t-il quelque chose de très basique ici?

Answer 1

Typiquement, cela se fait par votre modèle héritant d'une classe d'interface, IE:

template <class T> class Dendrite : public IDendrite 
{ 
     public: 
       Dendrite() 
       { 
       } 

       virtual ~Dendrite() 
       { 
       } 

       void Get(std::vector<T> &o) = 0; 

     protected: 
       std::vector<T> _data; 
}; 

et vous classe IDendrite peut être stocké sous forme de pointeurs:

std::vector<IDendrite*> m_dendriteVec; 

Cependant, dans votre situation, vous prenez le paramètre de modèle dans le cadre de votre interface. Vous devrez peut-être aussi envelopper ceci aussi.

class IVectorParam 
{ 
} 

template <class T> 
class CVectorParam : public IVectorParam 
{ 
    std::vector<T> m_vect; 
} 

vous donnant

class IDendrite 
{ 
    ... 
public: 
    virtual ~IDendrite() 
    virtual void Get(IVectorParam*) = 0; 
} 

template <class T> class Dendrite : public IDendrite 
{ 
    ... 
    // my get has to downcast to o CVectorParam<T> 
    virtual void Get(IVectorParam*); 
}; 

Answer 2

Oui, il est possible. Assurez-vous simplement de fournir des fonctions virtuelles et un destructeur virtuel. En outre, vous pouvez utiliser typeid pour obtenir le type réel (ainsi que dynamic_cast pour vérifier le type)