Templates und OOP

[Siassei]

Hallo drakon,

naja, ich möchte es ohne compilieren in Erfahrung bringen. Der Grund hierfür ist denkbar einfach. Eine automatische Typenanpassung erkennt man z.B. nur sehr schwer

Deutet deine Antwort darauf hin, dass ich entweder das Template für einen bestimmten Type setzen kann oder alle Typen zu lasse?

[drakon]

naja, ich möchte es ohne compilieren in Erfahrung bringen. Der Grund hierfür ist denkbar einfach. Eine automatische Typenanpassung erkennt man z.B. nur sehr schwer

?!
Du kannst mal sehen, was der Compiler zu deinem Code meint. Der hilft vielfach um rein syntaktische Fehler zu erkennen. Dein Code ist einfach schon mal schlichtweg falsch. Der Compiler wird dir dann sagen, was daran falsch ist und auch in etwa warum.
Dann kannst du nochmal nachlesen und dann wird dir irgendwann der Sinn dahinter klar.

Wenn du dich ein wenig mehr mit Templates, Compiletime Polymorphie beschäftigst, wirst du in etwa das erreichen, was du willst.

Ich würde dir aber empfehlen zuerst mal ein paar einfache Sachen mit Templates anzustellen. (z.B eine Vektorklasse für beliebige Typen).

[Nexus]

Zu Templates gibts übrigens auch einen schönen Artikel: http://www.c-plusplus.net/forum/viewtopic-var-t-is-128361.html

[Siassei]

Hallo,

danke für den schönen Beitrag von hier Aber irgendwie komme ich nicht weiter. Wieso ist Foo nicht definiert (gut das sehe ich noch ein) bzw. "Foo is not a type"?

Scheinbar geht das nicht und ich kann aus keinem Dokument lesen wieso? Für eine Antwort wäre ich sehr dankbar. Und zurück zu meinen Problem "Wie kann ich in C++ Typensicher programmieren?". In Java gibt's es seit 1.5 die Generics wie im meinen Beispielcode von vorher zu sehen war. Wie realisiere ich sowas in C++?

template<Foo T>
class Foo
{

	private:
		T *vari;

	public:
		Foo();

		~Foo();

		T& getVariRef();

};

#endif

template<Foo T>
Foo<T>::Foo()
{
}

template<Foo T>
Foo<T>::~Foo()
{
}

template<Foo T>
T& Foo<T>::getVariRef()
{
	return this->getVariRef();
}

template<FooChild T>
class FooChild : Foo<T>
{

};

[Siassei]

Achja ich hab mich noch gar nicht über meine Umgebung geäusert

Linux KUbuntu
gcc

Als IDE werde ich KDevelop ein. Leider bin ich nicht so ganz mit der automatischen Codegeneration bzw. des Popups-Menü zufrieden. Da wurde ich von Java mit Netbeans gerade zu verwöhnt Das ist wohl in C++ etwas ...

Die Fragen aus meinen letzten Post sind nach wie vor offen

[JustAnotherNoob]

template<Foo T>
das ist nicht was du denkst.
Du übergibst hier keinen Typ.
Typübergabe geht nur mit class oder typename.

[void*]

Was soll eigentlich der Sinn dahinter sein ein template zu machen und es dann auf GENAU einen Typen festzunageln?

[Siassei]

void* schrieb:

Was soll eigentlich der Sinn dahinter sein ein template zu machen und es dann auf GENAU einen Typen festzunageln?

Einen Type und alle Kindklassen von diesem Typ.
Der Sinn? Typensicheres programmieren. Bei der Kindklasse sollte sich der Typ T automatisch nach FooChild wandeln -> erstelle ich eine Instanz der FooChild Klasse so gibt mir FooChild->getVariRef() automatisch FooChild zurück. Vielleicht nicht das beste Beispiel In Java und C# ohne Probleme möglich in C++ komme ich nicht drauf.

Kennt das hier keiner?

[JustAnotherNoob]

Ich verstehe immer noch nicht warum du keine Polymorphie verwendest, wenn dir das so wichtig ist.

Und Typsicher ist es sowieso.

[Siassei]

Ich schreibe hier mal ein Java - Beispiel. Hoffentlich könnt ihr das lesen und mir ein paar Tipps für eine C++ Umsetzung geben

interface Knoten<T> {
T getParent();
T getChild();
}

class TreeElement<E extends TreeElement, T> implements Knoten<T> {
// Irgendwelche Hilfsmethoden
public E getElement() { return this; }
}

class Blatt<T> extends TreeElement<Blatt, T> {
//
}

class Zweig<T> extends TreeElement<Zweig, T> {
//
}

So, in den Klassen Blatt und Zweig werden nun alle mit E Deklarierten Typen der TreeElement - Klasse an Blatt bzw. Zweig angepasst. TreeElement ist keine abstrakte Klasse und es kann somit auch eine Instanz hier von erstellt werden. Hier wäre der Rückgabewert E vom Typ TreeElement.

[drakon]

Du gehst das falsch an. Du darfst einer Sprache keinen anderen Stil aufzwingen. Löse es besser mit C++ Mitteln und Vorgehensweisen. Sonst kannst du ja Java nehmen.

[Siassei]

drakon schrieb:

Du gehst das falsch an. Du darfst einer Sprache keinen anderen Stil aufzwingen. Löse es besser mit C++ Mitteln und Vorgehensweisen. Sonst kannst du ja Java nehmen.

Ich habe nicht vor C++ irgend etwas auf zu zwingen Wie löse ich das in C++? Ich dachte immer das C++ objektorientierte Programmierung unterstützt, aber ausser Klassen und Vererbung hab ich da kein weiteres Konzept aus OOP gefunden.

Also, wie löse ich das in C++?

[JustAnotherNoob]

jetzt musst du dich aber entscheiden.
Entweder du benutzt generische Programmierung und damit Templates.
Oder du gehst rein OOP und benutzt Polymorphie, wie Java in seinen frühen Tagen.

Bei deinem Beispiel hab ich das Problem, dass ich nicht verstehe was du mit T willst.

[Siassei]

T ist irgendeine Klasse. Auf das Beispiel bezogen: Eine Klasse die von der Baumstruktur gespeichert und verwaltet wird. Wieder ein schlechtes Beispiel Vielleicht liegt es daran, dass ich am Abend nicht mehr so klar denken kann, da ich bereits um 4 Uhr aufstehe

[drakon]

Entweder du benutzt generische Programmierung und damit Templates.
Oder du gehst rein OOP und benutzt Polymorphie

Generische Programmierung ist ebenfalls eine Art Polymorphie. Einfach eine, die zur Kompilierzeit aufgelöst wird und nicht zur Laufzeit, wie, was du wahrscheinlich unter den Namen Polymorphie verstehst, mit virtuellen Funktionen.

[Siassei]

Wofür benötige ich dann Templates? Die sind doch für solche Anwendungsfälle da, oder?

[Zeus]

Nun deine Struktur macht wenig Sinn.

Wenn dann lieber so:

template<class T>
class TreeComponent
{
public:
	TreeComponent() {}
	virtual ~TreeComponent() {}

	virtual void AddElement(const T&) = 0;

	virtual void DeleteElement() = 0;
};

template<class T>
class Node : public TreeComponent<T>
{
public:
	virtual void AddElement(const T& element) {
		_childs.push_back(element);
	}

	virtual void DeleteElement() {
	}

private:
	std::deque<T> _childs;
};

template<class T>
class Leaf : public TreeComponent<T>
{
public:
	virtual void AddElement(const T& element) {
		data = element;
	}

	virtual void DeleteElement() {
	}	
private:
	T data;
};

[hustbaer]

Ich verstehe das Problem nicht ganz. Meist ergibt sich die geforderte Typsicherheit von alleine:

class Foo;

template <class T> class Bar // T muss von Foo abgeleitet sein
{
public:
    void Blah()
    {
        Foo* foo = m_t; // implizite Konvertierung nach Foo*
        foo->TuWas();
    }

private:
    T* m_t;
};

Versuch mal das mit einem T zu instanzieren das nicht von Foo abgeleitet ist...

----

drakon schrieb:

Du darfst einer Sprache keinen anderen Stil aufzwingen.

Man darf schon. Ist meist nicht sinnvoll, aber ... manchmal eben doch. In dem Fall vielleicht weniger.

[drakon]

hustbaer schrieb:

----

drakon schrieb:

Du darfst einer Sprache keinen anderen Stil aufzwingen.

Man darf schon. Ist meist nicht sinnvoll, aber ... manchmal eben doch. In dem Fall vielleicht weniger.

Ja. Dürfen tut man alles. Ich korigiere mal: "sollen".

[Siassei]

hustbaer schrieb:

Ich verstehe das Problem nicht ganz. Meist ergibt sich die geforderte Typsicherheit von alleine:

class Foo;

template <class T> class Bar // T muss von Foo abgeleitet sein
{
public:
    void Blah()
    {
        Foo* foo = m_t; // implizite Konvertierung nach Foo*
        foo->TuWas();
    }

private:
    T* m_t;
};

Das kann schon sein, dass in 90% der Fälle die Typensicherheit von Haus aus gesichert ist. Aber wie stellst du sicher, dass eine implizite Konvertierung nach Foo möglich ist? Ich kann ja theoretisch alle mögliche Klassen für T festlegen.

// Edit: Hätte ich die Möglichkeit T auf eine abstracke Klasse zu beschränken, wäre eine 100% Sicherheit garantiert, sofern diese Klasse eine Methode ToWas() besitzt.

class Foo;

template <class T> class Bar // T muss von Foo abgeleitet sein
{

private:
     T* m_t;

public:
    void Blah()
    {
        Foo* foo = this->m_t; // implizite Konvertierung nach Foo*
        foo->TuWas();
    }

private:
    T* m_t;
};