ich würde gerne Laufzeitpolymorphie über templates hinbekommen. mtx soll
hier je nach if-else unterschiedlichen typ haben. allerdings weiß ich keine bessere lösung als Field von einer basiklasse erben zulassen um mtx auch im catch-block erreichbar zu machen. geht das nicht anders? ich würde mir gern die basisklasse sparen. Kommentiere ich das ein geht es natürlich.

danke euch

class Field_Base
{
    public:
};

template<class T>
class Field //: public Field_Base
{
    public:

};

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

        try {
            if (true) Field<double>* mtx = new Field<double>();
        } catch (std::runtime_error& ex)
        {
            delete mtx;       
        }

        delete mtx;
        return 0;
}

ich würde gerne Laufzeitpolymorphie über templates hinbekommen.

Das ist per Definition nicht möglich, da Templates vollständig zur Compilezeit ausgewertet werden. Du musst also tatsächlich Laufzeitpolymorphie (virtuelle Funktionen) verwenden.

Was allerdings der folgende Code bewirken soll, verstehe ich nicht. Vielleicht wird dein Anliegen mit sinnvollem, ausdrucksstarkem Code besser verständlich.

try {
            if (true) Field<double>* mtx = new Field<double>();
        } catch (std::runtime_error& ex)
        {
            delete mtx;       
        }

        delete mtx;

...Das ist per Definition nicht möglich, ...

Sagen wir mal so: Templates behindern zwar Laufzeitpolymorphie nicht ... sie tragen aber zu dieser nichts bei.
Genauso wie const....

Gruß,

Simon2.

#include <iostream>
#include <stdexcept>

class Field_Base
{
    public:
};

template<class T>
class Field //: public Field_Base
{
    public:

};

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

//         try {
//             if (true) Field<double>* mtx = new Field<double>();
//         } catch (std::runtime_error& ex)
//         {
//             delete mtx;       
//         }
        if (true) Field<double>* mtx = new Field<double>();
        else Field<int>* mtx = new Field<int>();

        return 0;
}

mein obiger code solte so ausshen - das delete mtx; am ende ist weg.
ich möchte einfach auf die variable auch im catch-block zugreifen. schaffe ich das ohne basisklasse nicht?

#include <iostream>
#include <stdexcept>

class Field_Base
{
    public:
};

template<class T>
class Field //: public Field_Base
{
    public:

};

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

        try {
            if (true) Field<double>* mtx = new Field<double>();
        } catch (std::runtime_error& ex)
        {
            delete mtx;       
        }

        return 0;
}

Ich glaub du solltest ein paar Informationen liefern, ansonsten kann dir nur einer
von der Hellsehern mit der Kristallkugel helfen.

EDIT: Da sind ja neue Infos gekommen, während ich getippt habe
EDIT 2: Dein Code ist trotzdem nicht kompilierfähig

mein obiger code solte so ausshen - das delete mtx; am ende ist weg.
ich möchte einfach auf die variable auch im catch-block zugreifen. schaffe ich das ohne basisklasse nicht?

Das tut alles nicht das was du erwartest:

1)an eine Variable mtx im catch-Block kommst du nur wenn diese Variable entweder vordem try-Block, im catch-Block selber oder in der catch-Anweisug defniert hast.
2) in den beiden if/else-blöcken definierst du jeweils eine neue Variable, die beide auch den Namen mtx haben - diese sind nur im jeweiligen Block der if/else-Anweisung gültig, so dass du, da du ihnen ein mit new erzeugtes Objekt zuweist, ein Speichereck hast. Die Variable mtx, die du vor dem try block definiert hast (und ohne die das alles eh nicht kompiliert), bleibt wie sie ist.

Die direkte Antwort auf deine Frage ist: du brauchst eine Basisklasse und du müsstest einen Pointer auf diese Basisklasse vor dem Try-Block definieren. UND du musst die Pointer auf die mit new erzeugten Objekte diesem Basispointer zu weisen und nicht irgendwelchen neuen lokalen Variablen mit gleichem Namen.

Aber eine wichtige Information hast du nicht geliefert - was du mit alldem erreichen willst. Das sieht irgendwie aus als versuchst du ein Problem evtl. mit den falschen Mitteln zu lösen.

EDIT 2: Dein Code ist trotzdem nicht kompilierfähig

bei mir ist er das (linux+ g++ v 4.1.2)

Was willst du mit deinem field denn vor dem Löschen machen?

Methoden von field aufrufen und auch field an andere Klassenmethoden übergeben z.B.

Hmm danke aber das verstehe ich nicht.
Ich kann doch durchaus eine if-else bedingung machen in der ich abfrage was ich haben will. evtl. ist die bezeichnung laufzeit-polymorphie hier verkehrt?
ich meine sowas geht:

if (true) Field<double>* mtx = new Field<double>();
        else Field<int>* mtx = new Field<int>();

Nein, sowas geht nicht. Zumindest nicht über den Scope der If-Else-Abfrage hinaus und damit ist keine Polymorphie möglich.

Hambo schrieb:

try {
            if (true) Field<double>* mtx = new Field<double>();
        } catch (std::runtime_error& ex)
        {
            delete mtx;       
        }

Wie gesagt, was bringt das? Wenn new fehlschlägt und std::bad_alloc wirft (die nicht von std::runtime_error abgeleitet ist), wird der Speicher automatisch freigegeben. Und das if(true) bringt ja wohl gar nichts.

Wenn du Laufzeitpolymorphie willst, kommst du nicht an virtuellen Funktionen vorbei. Bzw. die Alternativen sind meistens noch viel mehr Gefrickel (manuelle Fallunterscheidungen).

Aber eine wichtige Information hast du nicht geliefert - was du mit alldem erreichen willst. Das sieht irgendwie aus als versuchst du ein Problem evtl. mit den falschen Mitteln zu lösen.

Ich lese eine datei ein in der entweder eine reelle oder komplexe matrix liegt. diese möchte ich templateabhängig einlesen und datenstrukturen darauf generieren. das passiert z.B. in der Field-Klasse - der Name Matrix-klasse wäre hier wohl sinnvoller. Das kann ich aber erst zur laufzeit entscheiden.
anschließend übergebe ich dieses objekt an den algorithmus (anderes objekt z.B.)

Wenn new fehlschlägt und std::bad_alloc wirft (die nicht von std::runtime_error abgeleitet ist), wird der Speicher automatisch freigegeben.

passiert das auch im falle std::runtime_error ?

Es ist doch unsauber bei einem catch einfach nur ein return reinzuklatschen und
keinen heap freizugeben oder?

Ich lese eine datei ein in der entweder eine reelle oder komplexe matrix liegt. diese möchte ich templateabhängig einlesen und datenstrukturen darauf generieren.

Schreib dir eine Basisklasse für die Matrix (möglicherweise reines Interface mit pur-virtuellen Funktionen) und leite davon das Template ab.

Hambo schrieb:

passiert das auch im falle std::runtime_error ?

Du meinst, falls der Konstruktor der Klasse einen std::runtime_error wirft? Ja, der entsprechende operator delete wird aufgerufen, um den Speicherplatz freizugeben. Das muss ja der Fall sein, da man den Speicher sonst unweigerlich verlieren würde (denk dran, ein fehlgeschlagenes new kann keine gültige Adresse zurückgeben).

Hambo schrieb:

Es ist doch unsauber bei einem catch einfach nur ein return reinzuklatschen und
keinen heap freizugeben oder?

Wieso freigeben, was schon freigegeben wurde? Das führt zu undefiniertem Verhalten. Das wäre unsauber.

Ein try-catch brauchst du, wenn du zusätzlichen manuellen Speicher angefordert hast oder auf eine andere Weise auf Fehler reagieren willst. Aber sicher nicht per se.

#include <iostream>

template<typename T>
class Field
{
public:
        typedef T type;
        T value;
};

template<typename T> void doSomething(T& t){
        typename T::type value = t.value;
        t.value = value / 3;
}

int main(int argc, char** argv)
{
       int i=0;
       if (i==0){
                Field<double> mtx;
                doSomething(mtx);
       } else {
                Field<int> mtx;
                doSomething(mtx);
       }

        return 0;
}

Also hier ist dein Field auf dem Stack -> keine Gefahr wegen Exception
Wenn du jetzt noch nen return type für doSomething einführst, der ja
(hoffentlich) eine Schnittstellendefinition hat, dann kannst alles in
Template-Funktionen behandeln und das Schnittstellen-fähige Object zurückliefern.

#include <iostream> 

template<typename T> 
struct Field 
{ 
	T value; 
}; 

template<class T> void doSomething(Field<T>& t) { 
        // t.value = value / 3; 
	    // Don't Call it!
} 

template<> void doSomething<int>(Field<int>& t) {
	t.value = t.value / 3; 
}

template<> void doSomething<double>(Field<double>& t) {
	t.value = t.value / 3.0; 
}

int main(int argc, char** argv) 
{ 

        Field<double> a; 
        doSomething(a); 

        Field<int> b; 
        doSomething(b); 

        return 0; 
}

!!! Achtung! Das folgende Bsp. kompiliert nicht!

#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<T>*& mtx) = 0;
};
template<class T>
class Reader : public Reader_Base
{
    public:
        void read(Mtx<T>*& mtx) {}

};

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

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

// !!!!!!!! Geht nicht !?
        virtual void read(Mtx<T>*& mtx) = 0;

Warum eine Referenz auf einen Zeiger auf eine Mtx<T> -Instanz als Parameter? Spricht etwas gegen Mtx_Base& ?

Übrigens solltest du, wenn du schon unbedingt selbst Speicher verwalten willst, diesen wieder mit delete freigeben.

Gibst ein Grund warum dies nicht vorgeschlagen wird?:

#include <iostream> 

template<typename T> 
struct Field 
{ 
	T value; 
}; 

template<class T> void doSomething(Field<T>& t) { 
        // t.value = value / 3; 
	    // Don't Call it!
} 

template<> void doSomething<int>(Field<int>& t) {
	t.value = t.value / 3; 
}

template<> void doSomething<double>(Field<double>& t) {
	t.value = t.value / 3.0; 
}

int main(int argc, char** argv) 
{ 

        Field<double> a; 
        doSomething(a); 

        Field<int> b; 
        doSomething(b); 

        return 0; 
}

Hi Zeus,

ich wollte nur zeigen, dass er nicht alles doppelt implementieren muss, wenn
er Templates verwendet.

Ich hatte auch erst überlegt, ob ich in meiner Templatefunktion noch eine andere
Funktion aufrufe, die bei double und int unterschiedliche Funktionen aufruft, da
dieser Funktionsname für doube und int existiert.

arum eine Referenz auf einen Zeiger auf eine Mtx<T>-Instanz als Parameter? Spricht etwas gegen Mtx_Base&?

ich steh immer noch aufm schlauch.
kann ich denn das Mtx-Objekt dann verändern? Also über *& ? Geht das wenn ich einen pointer setze oder muss ich es wirklcih nur per referenz machen. Aber auch so krieg ichs leider net hin:

#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_Base& 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;
}

Meldung ist:

test2.cpp: In function »int main(int, char**)«:
test2.cpp:43: Fehler: keine passende Funktion für Aufruf von »Reader_Base::read(Mtx_Base*&)«
test2.cpp:22: Anmerkung: Kandidaten sind: virtual void Reader_Base::read(Mtx_Base&)

kann ich denn das Mtx-Objekt dann verändern? Also über *&

Vergiss erst mal Referenzen auf Zeiger, die brauchst du hier nicht.

Beim Aufruf von read() musst du nicht den Zeiger übergeben, sondern eine Referenz auf das Objekt (und nicht auf den Zeiger!), auf welches der Zeiger zeigt. Also musst du mtx zuerst dereferenzieren.

#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;
}

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.

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

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;
}