Destructor? kurze info bitte

Hallo zusammen,

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;

}

Bashar

Der Destruktor wird immer dann aufgerufen, wenn ein Objekt (das einen Destruktor hat ...) zerstört wird. Das passiert also:

bei automatischen Objekten (auf dem Stack), wenn ihr Gültigkeitsbereich verlassen wird
bei dynamischen Objekten (auf dem Heap, mit new erzeugt), wenn sie 'delete't werden
bei statischen Objekten, wenn das Programm zuende ist
(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.

thordk

seh da irgendwie keinen destructor...

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.

Das heisst ich bekomme 11 "outta here" outputs weil ich 11 elemente in meinen 3 List's 'a' 'b' und 'z' hab? 3 Elemente in a, 4 in b und 4 in z? Oh jetzt seh ich das erst mal, ich hab ja mehr als 11 outta heres im output. 3 oben und 11 unten, macht 14. Aber die unteren 11 hab ich schon richtig erkannt ne?

Jetzt versteh ich irgendwie nichts mehr.
Hab die Zeile

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?

Z2

Das hier:

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.

Macht Sinn!

Danke