Laufzeitpolymorphie über Templates?

sorry...ich bin zu blöd. auch so gehts nicht (siehe unten).
kannst du mir den code vielleicht zeigen den du meisnt. ich bekomme ständig undefined references oder eben errors.

#include <iostream>

class Mtx_Base
{
    public:
        virtual ~Mtx_Base();
        virtual void foo() = 0;
};
template<class T>
class Mtx : public Mtx_Base
{
    public:
        void foo() {};

};

class Reader_Base
{
    public:
        virtual ~Reader_Base();
        // !!!!!!!! Geht nicht !?
        virtual void read(Mtx_Bas& mtx) = 0;
};
template<class T>
class Reader : public Reader_Base
{
    public:
        void read(Mtx_Base& mtx) {}

};

int main(int argc, char** argv)
{
    Mtx_Base      *mtx = NULL;

    Reader_Base* reader = NULL;

    if (true) 
    {
        mtx = new Mtx<double>();
        reader = new Reader<double>();
    }
    reader->read(*mtx);

    delete mtx;
    delete reader;
    return 0;
}

Nexus

Hast du die Fehler überhaupt angeschaut? Achte nur auf die Zeilennummer, du hast einen Tippfehler.

Und natürlich musst du die verwendeten Funktionen auch definieren. Da der rein virtuelle Destruktor von der abgeleiteten Klasse aufgerufen werden muss, sollte er trotzdem eine (leere) Definition erhalten.

Danke. Jetzt versteh ichs auch. so klappte es danke!

Eh moment noch

kann ich jetzt noch mit dem pointer rangehen? als Matrix_Base*& mtx in die signatur übergeben oder verstehe ich hier noch etwas nicht ?

Ah klappt auch Danke

Ich hätte zu unserem Beispiel noch eine frage.
Ich habe jetzt in Mtx einen Member Lines der templatebasiert ist.
So kann ich den natürlich dann in Reader nicht verwenden weil in read()
nur ein Mtx_Base zur Verfügung steht. Ich könnte Lines in Mtx_Base als member verfrachten aber dann kann ich keinen template-typen angeben für Lines dort. Muss ich dann wieder eine Basisklasse Lines_Base erstellen und diese dann in Mtx_Base definieren. Das ganze wird ja immer umständlicher....

Kann mir jemand helfen? Danke

#include <iostream>
template<class T>
class Lines
{
    public:
        Lines<T> () {}
        ~Lines<T>() {}      
};

class Mtx_Base
{
    public:
        virtual ~Mtx_Base() {}
        virtual void foo() = 0;
};
template<class T>
class Mtx : public Mtx_Base
{
    public:
        Mtx() { lines = NULL;}
        void foo() {};
        Lines<T> * lines;

};

class Reader_Base
{
    public:
        virtual ~Reader_Base() {}
        // !!!!!!!! Geht nicht !?
        virtual void read(Mtx_Base*& mtx) = 0;
};
template<class T>
class Reader : public Reader_Base
{
    public:
        void read(Mtx_Base*& mtx) {
            mtx->lines = new Lines<T>();
        }

};

int main(int argc, char** argv)
{
    Mtx_Base      *mtx = NULL;

    Reader_Base* reader = NULL;

    if (true) 
    {
        mtx = new Mtx<double>();
        reader = new Reader<double>();
    }
    reader->read(mtx);

    delete mtx;
    delete reader;
    return 0;
}

Nexus

Hambo schrieb:

virtual void read(Mtx_Base*& mtx) = 0;

Zum dritten Mal: Du brauchst keine Referenz auf einen Zeiger. Probier nicht einfach herum, bis keine Kompilierfehler mehr kommen. Das führt nämlich zu nichts, sondern hindert dich nur daran, die Thematik richtig zu verstehen. Ich habe ja bereits Vorschläge für einen sinnvollen Parametertypen gebracht.

Hambo schrieb:

Ich könnte Lines in Mtx_Base als member verfrachten aber dann kann ich keinen template-typen angeben für Lines dort. Muss ich dann wieder eine Basisklasse Lines_Base erstellen und diese dann in Mtx_Base definieren. Das ganze wird ja immer umständlicher....

Polymorphie bringt dir nichts, solange du in den abgeleiteten Klassen keine Funktionalität implementierst. Momentan hast du nur nichts-tuende Funktionen. Eine weitere Indirektion verschiebt das Problem ebenfalls nur.

Überlege dir, wie du mit Lines arbeiten kannst. Reicht es nicht, wenn diese Variable erst in den abgeleiteten Klassen Mtx bekannt ist?