Wie finde ich raus wie die der Destructor funktioniert. Hab hier nen code, aber kann nich genau verstehen wann der Destructor gerufen wird. Gibts da irgendwo vielleicht FAQ's zu? Ich hab nichts gefunden. Hier is der Code, und wie ihr ja sehen koennt gibt das Programm jedes mal wenn der destructor gerufen wird "outta here" aus.

#include <iostream>
#include <string>

using namespace std;

class Node {
	int data;
	Node *next;
public:
	Node() : data(0), next(0) { }
	Node(int e) : data(e), next(0) { }
	Node(int e, Node* n) : data(e), next(n) { }
	Node *getNext(void) const { return next; }
	int getData(void) const { return data; }
	void setData(int e) { data = e; }
	void setNext(Node* n) { next = n; }
};

class List {
	Node *start;
public:
	List() : start(0) { }
	void push_back(int e) {
		Node *newone = new Node(e);
		if (start == 0)
			start = newone;
		else {
			Node *temp = start;
			while (temp->getNext() != 0)
				temp = temp->getNext();
			temp->setNext(newone);
		}
		return;
	}
	friend ostream& operator<<(ostream&, const List&);
};

ostream& operator<<(ostream& os, const List& l) {
	os << "< ";
	Node *temp = l.start;
	while (temp) {
		os << temp->getData() << " ";
		temp = temp->getNext();
	}
	os << ">";
	return os;
}

int main( ) {
	List a, b;
	cout << "Adding 10, 20, 30, 40, and 50 to a" << endl;
	a.push_back(10);
	a.push_back(20);
	a.push_back(30);
	a.push_back(40);
	a.push_back(50);
	cout << "List a is " << a << endl;
	cout << "Assigning a to b" << endl;
	b = a;
	cout << "List b is " << b << endl;
	cout << "Adding 60 and 70 to b" << endl;
	b.push_back(60);
	b.push_back(70);
	cout << "List b is now " << b << endl;
	cout << "List a is now " << a << endl;
	cout << "Declaring a new list c that is the same as a" << endl;
	List c(a);
	cout << "Adding 80 and 90 to c" << endl;
	c.push_back(80);
	c.push_back(90);
	cout << "List c is now" << c << endl;
	cout << "List b is now" << b << endl;
	cout << "List a is now" << a << endl;

}

1. bei automatischen Objekten (auf dem Stack), wenn ihr Gültigkeitsbereich verlassen wird
2. bei dynamischen Objekten (auf dem Heap, mit new erzeugt), wenn sie 'delete't werden
3. bei statischen Objekten, wenn das Programm zuende ist
4. (wenn der Destruktor explizit aufgerufen wird, nur der Vollständigkeit halber, das geht, aber ist nichts für dich im Moment )

Aber ich denke, du solltest das zum einem an einem geeigneteren Anschauungsobjekt mal nachvollziehen und zum anderen dir auch angucken, wann Objekte erzeugt werden, d.h. mal alles durchhecheln was ich oben so genannt habe (ausser 4.), dazu Call-by-Value, temporäre Objekte usw. usf.

das ding wird immer aufgerufen, wenn ein objekt zerstört wird.

objekte werden entweder zerstört, wenn ihr gültigkeitsbereich verlassen wird oder wenn der speicher per delete freigegeben wird.

struct A;

void speicherleck()
{
 A a;
 A *b = new A;
}

void dollesding()
{
 A c;
 A *d = new A;
 delete d;
}

int main()
{
 speicherleck();
 dollesding();
}

nachdem speicherleck() durchgelaufen ist endet der gültigkeitsbereich der variablen a und b. a wird gelöscht und der desktruktor aufgerufen. b wird nicht gelöscht, also auch kein destruktor. da allerdings der handle futsch ist, hat man hier nen schickes speicherleck gebaut.

nachdem dollesding() durchgelaufen ist, wird c wiedermal gelöscht. der speicher von d wird freigeben (delete) und somit auch der destruktor aufgerufen.

void Fun(List){cout << "Fun"<< endl;}

um geandert zu

void Fun(List&){cout << "Fun"<< endl;}

und die Funktion ruft den destructor nich mehr, das heisst ich bekomme keine drei outta here mehr wenn ich in der main

a.Func(b);

aufrufe.
Wie is das zu erklaeren?

void Fun(List){cout << "Fun"<< endl;}

legt eine Kopie des übergebenen List-Objekts an. Und die muß schließlich auch wieder destruiert werden.

Das hier:

void Fun(List&){cout << "Fun"<< endl;}

verwendet lediglich eine Referenz auf das übergebene Objekt. Es wird keine Kopie angelegt, folglich ist auch kein Destruktor-Aufruf notwendig.

Danke