main.cpp

#include <iostream>
#include "Client.h"
#include "BinTree.h"

using namespace std;

int main() {
	BinTree<Client> b1 = BinTree<Client>(); // Löst Fehler aus
	//Client *c1 = new Client(4300, "Hakon H.");
	return 0;
}

BinTree.h

#ifndef BINTREE_H
#define BINTREE_H
#include "Node.h"
#include "Root.h"
#include "Client.h"

template <class T>
class BinTree {

private:
	Root<T> *root;

public:
	BinTree();
	~BinTree();
	void Append(T*);
};

// Definitionen

template <class T>
BinTree<T>::BinTree() {
	root = new Root<T>();
}

template <class T>
BinTree<T>::~BinTree() {
	delete root;
}

template <class T>
void BinTree<T>::Append(T *data) {
	root->Append(data);
}

#endif

Root.h

#ifndef ROOT_H
#define ROOT_H
#include "Node.h"
#include "TreeNode.h"

template <class T>
class Root : public Node<T> {

private:
	Node<T> *next;

public:
	Root();
	~Root();
	Node<T>* Append(T* data);
};

// Definitionen

template <class T>
Root<T>::Root() {
	next = new TreeNode<T>(this);
}

template <class T>
Root<T>::~Root() {
	delete next;
}

template <class T>
Node<T>* Root<T>::Append(T *data) {
	next->Append(data);
	return next;
}

#endif

TreeNode.h

#ifndef TREENODE_H
#define TREENODE_H
#include "Node.h"

template <class T>
class TreeNode : public Node<T> {

private:
	Node<T> *next;
	Node<T> *prev;
	T *data;

public:
	TreeNode(Node<T>*);
	~TreeNode();
	Node<T>* Append(T*);
};

// Definitionen

template <class T>
TreeNode<T>::TreeNode(Node<T> *prev) {
	this->prev = prev;
}

template <class T>
TreeNode<T>::~TreeNode() {
	delete next;
}

template <class T>
Node<T>* TreeNode<T>::Append(T *data) {
	if(this->data == NULL) {
		this->data = data;
		next = new TreeNode<T>(this);
	}
	else
		next->Append(data);
	return this;
}

#endif

Alles in allem sieht's für mich seltsam aus:
was macht denn Append z.B.

Vielleicht solltest du mal einen Gang runterschalten und es ohne templates versuchen.

BinTree gibt es einfach an Root weiter. Root darf/soll/kann keine Daten aufnhemen (ist ja nur die Wurzel) Next zeigt auf ein neues Element (TreeNode). TreeNode prüft, ob der Inhalt (data) ein NULLZeiger ist oder nicht. Wenn ja, dann fülle mit der Adresse von T (also Klasse "Client"), und lasse next auf einen neuen TreeNode zeigen. Wenn es kein Nullzeiger ist, dann überlass Anfügen dem next.

Bei dem Code stürzt das Programm ab, wieso?

weil irgendwo ein fehler ist

Unbehandelte Ausnahme bei 0x0040124d in BinTree.exe: 0xC0000005: Zugriffsverletzung beim Lesen an Position 0xbaadf00d.

Ich muss irgendwas mit den Zeigern verwurschtelt haben.

Der Fehler passiert nicht, wenn ich die Kurzform des Konstruktor-Aufrufes verwende:

BinTree<Client> b1();
// statt
BinTree<Client> b1 = BinTree<Client>();

Aber dann mit der Warnung:

Warnung 1 warning C4930: 'BinTree<T> b1(void)': Funktion mit Prototyp wurde nicht aufgerufen (war eine Variablendefinition gemeint?) c:\Dokumente und Einstellungen\Ad aCTa\Desktop\C++\BinTree\BinTree\main.cpp 8

Hä?

BinTree<Client> b1();

deklariert eine Funktion namens b1 ohne Parameter welche ein BinTree<Client> Objekt zurückgibt. Das sagt auch die Warnung.

sieht doch verdammt nach :

int foo ();

aus, nicht? Klingelts?

Zu dem Fehler. Debug die Applikation einfach mal und geh alle Konstruktoren durch. (Das ist ja das einzige, was du überhaupt machst). Dann siehst du genau, wo der Fehler liegt.

Ich kann zum Verständis sagen, was ich von dem Code will:

Wenn der Konstruktor von BinTree aufgerufen wird, soll in BinTree::root ein Zeiger eines neu erstellten Root-Objektes gespeichert werden.

root = new Root<T>();

Wird der Root-Konstruktor dadurch wiederrum aufgerufen, so soll dieser in Root::next eine Adresse eines neu erzeugten TreeNode-Objekts speichern, dabei übergibt er seine eigene Adresse an TreeNode.

next = new TreeNode<T>(this);

Dieses Objekt schreibt in seinem Konstrukor die Adresse wiederrum in seinen prev-Zeiger, der next von TreeNode wird erst befüllt, wenn Append aktiviert wird.

this->prev = prev // Parameter des Konstruktors

Ich habe cout-Ausgaben überall in jedem Konstruktor erfolgreich ausführen können, wie gesagt, das Programm stürzt immer ab, egal, ob was im Konstruktor von BinTree steht. Damit ist der Fehler ja irgendwo dort, bloß wo?

Ich habe cout-Ausgaben überall in jedem Konstruktor erfolgreich ausführen können, wie gesagt, das Programm stürzt immer ab, egal, ob was im Konstruktor von BinTree steht. Damit ist der Fehler ja irgendwo dort, bloß wo?

Wie viel mal muss ich es noch sagen:
Schalte den Debugger an und geh einfach von Anfang an jeden Schritt durch.. Dann wirst du früher oder später den Fehler kriegen.. Und dann weisst du auch, wo der ist..

Daher gilt die Regel, dass du, wenn du deinen der Konstruktoren definierst, die anderen ebenfalls definierst.

Hier findest du auch, wie man das richtig macht:
http://tutorial.schornboeck.net/bigthree.htm

btw:
Der Compiler hat mit dem schon lange nichts mehr zu tun. Sobald eine exe da ist, ist der Compiler unbeteiligt..