ich benutze eine DLL in meinem Projekt. Bevor ich die DLL benutzen kann muß ich ein paar Init Funktionen aufrufen. Wenn ich die DLL nicht mehr brauche muß ich ein paar MakeClean Funktionen aufrufen. Sowohl Init als auch MakeClean dürfen nur einmal aufgerufen werden: Mache ich das mehrmals werden zB. Exceptions beim delete des Objektes geworfen das im Dekonstruktor die MakeClean Funktion hat.

1. Ich dachte mir folgendes: Ich packe Init/MakeClean in eine Klasse von der alle Klassen die die DLL bentzen abgeleiten müssen. Ich kann über eine static Variable mir merken ob die Init Routine schon einmal aufgerufen wurde. Aber wie kriege ich es hin das der Dekonstruktor dann aufgerufen wird wenn es keine Objekte der Basisklassen mehr gibt? Gibt es da ein Konstrukt das ich übersehen habe oder muß ich jetzt die Konstruktoraufrufe zahlenmäßig mit denen der Dekonstruktoraufrufe verrechnen?

2. Unabhängig von obigem Problem: Wenn ich in der Klasse den Konstruktor komplett weglasse wird ein Standard Konstruktor eingefügt. Gibt es zu diesem einen Unterschied wenn mein Konstruktor so aussieht?

MyClass::MyClass() {}

3. Warum muß der Dekonstruktor virtual sein?

A)
class MyClass {
~MyClass() {DoSomething();}; // Hier wird er immer bei der Zerstörung von MyClass aufgerufen.
}

B)
class MyClass {
virtual ~MyClass() {DoSomething();} // Hier kann er überschrieben werden.
}
class Derived : MyClass {
~MyClass() {} // Habe ich so den Aufruf von DoSomething() verhindert?
}

C)
class MyClass {
virtual ~MyClass()=0; // Hier muß er überschrieben werden.
}
class Derived : MyClass {
~MyClass() {DoSomething();} // Hier wird der BasisklassenDekonstruktor erstellt.
~Derived() {DoAbc();} // Hier der Dekonstruktor der abgeleiteten Klasse.
}

class MyClass {
virtual ~MyClass() {DoSomething();} // Hier kann er überschrieben werden

ansonsten müllst du deinen speicher bei solchen anweisungen zu:

Base *ptr = new Derived;
delete ptr; //hier würde ohne virtuel nur der basisklassenanteil zerstört werden
            //der derived anteil würd eunreferenziert im speicher verweilen

ein bsp aus einem anderen thread von mir:
(so soll es aussehen)

class Base{ 
public: 
Base() {std::cout<<"Base"<<std::endl; } 
virtual ~Base(){ std::cout<<"~Base"<<std::endl;} 
}; 

class D1 : public Base { 
D1 () {std::cout<<"D1 "<<std::endl; } 
~D1(){ std::cout<<"~D1 "<<std::endl;} 
 }; 

class D2 : public D1 { 
D2 () {std::cout<<"D2 "<<std::endl; } 
~D2(){ std::cout<<"~D2 "<<std::endl;}   
}; 

int main() 
{ 
  D2 d1; 
std::cout<<std::endl; 
}  

//output auf der konsole
Base 
D1 
D2 

~D2 
~D1 
~Base

@2: Wenn du nicht explizit über die Initialisierungsliste einen anderen Ctor anforderst, wird der Default-Konstruktor der Basisklasse aufgerufen - das ist in der Tat identisch zu deinem leeren Ctor. (aber wenn du irgendeinen eigenen Ctor anlegst, bekommst du keinen automatisch erzeugten Default-Ctor mehr - dann mußt du notfalls einen eigenen erzeugen)

@3: Ein virtueller Destruktor ist nicht nötig für Vererbung, aber für polymorphe Verwendung der Klassen:

base*p = new derived;
...
delete p;

(ohne virtuellen Dtor löschst du damit bestenfalls den base-Anteil von *p - afair ist sogar undefiniert, was dort herauskommt)

@Beispieltext:
B verhindert nicht, daß 'DoSomething()' aufgerufen wird - mit dem 'virtual' sicherst du nur ab, daß auch Derived aufgeräumt werden kann.
C ist Käse - niemand darf fremde Destruktoren definieren (und auch ein pur virtueller Dtor muß definiert werden, sonst fliegt er dir um die Ohren).

PS: Das heißt übrigens nicht "Dekonstruktor

class Vater{
public:
	Vater() {
		std::cout<<"Vater"<<std::endl;
	}
	virtual ~Vater() {
		std::cout<<"~Vater"<<std::endl;
	}
	// Ob ich nun diese Funktion virtual mache oder nicht scheint vollkommen Latte
	// zu sein. Egal ob ich nun DoIt in Kind überschreibe oder nicht.
	virtual void DoIt() {
		std::cout<<"DoIt Vater"<<std::endl;
	}
};

class Kind : public Vater {
public:
	Kind() {
		std::cout<<"Kind"<<std::endl;
	}
	~Kind() {
		std::cout<<"~Kind"<<std::endl;
	}
	void DoIt() {
		std::cout<<"DoIt Kind"<<std::endl;
	}
};

int main() {
	Kind *K;
	K = new Kind();
	K->DoIt(); // Hier wird nur DoIt vom Kind ausgeführt?
	delete K; // Hier werden aber beide Destruktoren ausgeführt?
	return 0;
}

2. Singleton
Wann wird der Dekonstruktor aufgerufen? Solange irgendwo noch ein Pointer auf dem Singleton ist geht es wohl nicht. Sobald der letzte Pointer aber weg ist kann das Objekt jederzeit zerstört werden. Korrekt? (Je nachdem wie der Kompiler das organisiert, einen Garbage Kollektor scheint es unter c++ nicht zugeben.)

class Singleton {
	private:
		//Konstruktor private, damit man sich keine Instanzen holen kann.
		Singleton() {
			// Hier eine Init Methode die nur einmal aufgerufen werden soll.
		}
		//Den Kopierkonstruktor schützen um zu vermeiden, dass das Objekt unbeabsichtigt kopiert wird.
		Singleton(const Singleton& cc){
		}

	public:
		~Singleton() {
			// Hier die Aufräumfunktionen die auch nur einmal aufgerufen werden sollen.
		}
		static Singleton* getInstance() {
			static Singleton instance; 
			return &instance; 
		}
};

int main() {
	Singleton *S = Singleton::getInstance();
	return 0;
}

Ich habe die Beispiele von Muffmolch ausprobiert. Der Destruktor von Base wird nur aufgerufen wenn er virtual ist. Das führt auf die Diskussion was virtual eigentlich soll? (Ich meine nicht pure virtual). Auch ohne virtual kann ich jede Methode überschreiben. Nach CStoll macht virtual bei der Vererbung keinen Sinn. Was meint polymorphe Verwendung? Könnte man dieses Vererbungsbeispiel so umstricken das der Sinn von virtual sichtbar wird?

Entweder ich habe mich falsch ausgedrückt oder du hast mich falsch verstanden - virtual ohne Vererbung macht keinen Sinn, aber man kann auch ohne virtual vererben. Und Polymorphie bedeutet, daß erst zur Laufzeit feststeht, was für ein Objekt du hast.

class Vater{
public:
	Vater() {
		std::cout<<"Vater"<<std::endl;
	}
	virtual ~Vater() {
		std::cout<<"~Vater"<<std::endl;
	}
	// Ob ich nun diese Funktion virtual mache oder nicht scheint vollkommen Latte
	// zu sein. Egal ob ich nun DoIt in Kind überschreibe oder nicht.
	virtual void DoIt() {
		std::cout<<"DoIt Vater"<<std::endl;
	}
};

class Kind : public Vater {
public:
	Kind() {
		std::cout<<"Kind"<<std::endl;
	}
	~Kind() {
		std::cout<<"~Kind"<<std::endl;
	}
	void DoIt() {
		std::cout<<"DoIt Kind"<<std::endl;
	}
};

int main() {
	Kind *K;
	K = new Kind();
	K->DoIt(); // Hier wird nur DoIt vom Kind ausgeführt?
	delete K; // Hier werden aber beide Destruktoren ausgeführt?
	return 0;
}

Ändere mal die main() um zu:

Vater* ptr = new Kind();
ptr->DoIt();
delete ptr;

Dann siehst du den Unterschied zwischen virtual und nicht-virtual.

2. Singleton
Wann wird der Dekonstruktor aufgerufen? Solange irgendwo noch ein Pointer auf dem Singleton ist geht es wohl nicht. Sobald der letzte Pointer aber weg ist kann das Objekt jederzeit zerstört werden. Korrekt? (Je nachdem wie der Kompiler das organisiert, einen Garbage Kollektor scheint es unter c++ nicht zugeben.)

Die einzige je existierende Singleton-Variable ist static - und damit wird sie bei einem regulären Programmende (exit() oder return aus der main()) auch normal zerstört. (bei einem Absturz allerdings nicht - aber bei einem Absturz ist sowieso nichts mehr zu retten)

Zu static Variablen: Wenn werden diese aus dem Speicher entfernt? Immer erst nach Programmende? Bei Funktionen ist es ja so das die static Variablen beim nächsten Funktionsaufruf wieder mit den gleichen Werten belegt sind.

Wie wäre das bei Threads? Wenn ich eine Klasse in verschiedenen Threads instanziiere, haben dann die static Variablen den gleichen Wert? Wahrscheinlich nicht.

martin_salo schrieb:

Zu static Variablen: Wenn werden diese aus dem Speicher entfernt? Immer erst nach Programmende?

Ja, übrigens gilt das auch für statics in Funktionen, denn was du schreibst ist nicht ganz eindeutig:

martin_salo schrieb:

Bei Funktionen ist es ja so das die static Variablen beim nächsten Funktionsaufruf wieder mit den gleichen Werten belegt sind.

Etwas "unscharf": Eine static-Variable wird angelegt (und initialisiert) beim ersten Aufruf, JEDER weitere Aufruf greift auf die gleiche Variable zu. Sie sind nicht nur mit gleichen Werten belegt, sie sind auch physikalisch gleich.

martin_salo schrieb:

Wie wäre das bei Threads? Wenn ich eine Klasse in verschiedenen Threads instanziiere, haben dann die static Variablen den gleichen Wert? Wahrscheinlich nicht.

Doch, weil es genau der gleiche Speicherbereich ist. Daher muss man mit statics und Threads besonders stark aufpassen!

Vielleicht noch eine Ergänzung: globale statics werden in nicht festgelegter Reihenfolge initialisiert, statics in Methoden wiederum erst wenn die Methode das erste mal aufgerufen wird. Dies ist besonders dann wichtig falls man abhängigkeiten in statics hat (Im Zweifel ist die Abfrage über eine Methode sicherer, da die Reihenfolge zumindest definiert ist).

cu André