Ein Zeiger auf abstrakte Vorlage Basisklasse?

Question

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

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

        virtual ~Dendrite()
        {
        }

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

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

Nun leite ich daraus die genaue Verwendung von Dendrite gibt.
Nun ist das Problem.
Wie kann ich ohne einen spezifischen Typ eines Vektors von Zeigern auf die Basis-Klasse erstellen, die Ich möchte später durch Schubelemente, um es spezifizieren? So 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 bin ich etwas fehlt sehr einfach hier?

Answer 1

Normalerweise wird dies durch die Vorlage erfolgt aus einer Interface-Klasse erbt, 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;

Doch in Ihrer Situation, Sie nehmen die Template-Parameter als Teil Ihrer Schnittstelle. Sie können auch diese müssen auch wickeln.

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. So stellen Sie sicher, dass virtuelle Funktionen und virtuelle destructor bereitzustellen. Darüber hinaus können Sie verwenden typeid den tatsächlichen Typ zu erhalten (wie auch dynamic_cast den Typ zu überprüfen)