Ein Zeiger auf abstrakte Template-Basisklasse?

Question

Ich kann das nicht herausfinden. Ich brauche eine abstrakte Vorlage Basisklasse zu haben, die ist die folgende:

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

     virtual ~Dendrite() 
     { 
     } 

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

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

Nun, ich daraus ableiten, die genaue Verwendung von Dendrite gibt.

Jetzt das Problem.

Wie erstelle ich einen Vektor von Zeigern auf die Basis-Klasse ohne spezifischen Typ, die ich später durch Drücken von Elementen angeben möchte? Etwas wie:

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

Ist das möglich oder fehlt mir hier etwas sehr Grundlegendes?

Answer 1

Typischerweise wird dies durch die Vorlage erfolgt aus einer Interface-Klasse erben, IE:

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

       virtual ~Dendrite() 
       { 
       } 

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

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

und dann könnten Sie IDendrite Klasse als Zeiger gespeichert werden:

std::vector<IDendrite*> m_dendriteVec; 

jedoch in Ihrem Situation, nehmen Sie den Template-Parameter als Teil Ihrer Schnittstelle. Möglicherweise müssen Sie dies auch umbrechen.

class IVectorParam 
{ 
} 

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

geben Sie

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

Ja, es ist möglich. Stellen Sie nur sicher, dass Sie virtuelle Funktionen und einen virtuellen Destruktor bereitstellen. Darüber hinaus können Sie typeid verwenden, um den tatsächlichen Typ zu erhalten (sowie dynamic_cast, um den Typ zu überprüfen)