Un puntatore alla classe di base del modello astratto?

Question

Non riesco a capirlo. Ho bisogno di avere una classe base modello astratto, che è la seguente:

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

     virtual ~Dendrite() 
     { 
     } 

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

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

Ora, derivano da questo che specifica l'utilizzo esatto di Dendrite.

Ora il problema.

Come si crea un vettore di puntatori alla classe base senza un tipo specifico, che voglio specificare spingendo gli elementi in seguito? Qualcosa di simile:

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

È possibile o mi manca qualcosa di molto semplice qui?

Answer 1

genere questo viene fatto dal vostro modello di ereditare da una classe di interfaccia, IE:

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

       virtual ~Dendrite() 
       { 
       } 

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

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

e quindi si sta classe IDendrite possono essere memorizzati come puntatori:

std::vector<IDendrite*> m_dendriteVec; 

Tuttavia, nella vostra situazione, stai prendendo il parametro template come parte della tua interfaccia. Potrebbe anche essere necessario avvolgere anche questo.

class IVectorParam 
{ 
} 

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

dando

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ì, è possibile. Assicurati di fornire funzioni virtuali e distruttori virtuali. Inoltre, è possibile utilizzare typeid per ottenere il tipo effettivo (nonché dynamic_cast per verificare il tipo)