¿Un puntero a la clase base de la plantilla abstracta?

Question

No puedo resolver esto. Es necesario disponer de una clase base abstracta plantilla, que es la siguiente:

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

     virtual ~Dendrite() 
     { 
     } 

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

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

Ahora, se derivan de esta, que especifica el uso exacto de la dendrita.

Ahora el problema.

¿Cómo creo un vector de punteros a la clase base sin un tipo específico, que quiero especificar presionando los elementos más adelante? Algo como:

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>()). 
}; 

¿Es esto posible o me falta algo muy básico aquí?

Answer 1

Normalmente esto se hace por la plantilla que hereda de una clase de interfaz, IE:

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

       virtual ~Dendrite() 
       { 
       } 

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

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

y luego estás clase IDendrite podría almacenarse como punteros:

std::vector<IDendrite*> m_dendriteVec; 

Sin embargo, en su situación, está tomando el parámetro de la plantilla como parte de su interfaz. Es posible que también deba envolver esto también.

class IVectorParam 
{ 
} 

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

dándole

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

Sí, es posible. Solo asegúrese de proporcionar funciones virtuales y destructor virtual. Además, puede usar typeid para obtener el tipo real (así como dynamic_cast para verificar el tipo)