myVector.~vector()

Sieht etwas komisch aus, er meckert aber nicht rum. Ist das der rictige Weg?

1310-Logik schrieb:

Destructoren dürfen nicht explizit aufgerufen werden.
Mach es besser über delete myVector, wenn Du ihn dynamisch angelegt hast.

Man darf sie wirklich nicht aufrufen? Ich dachte, dass das nur unüblich sei.

chrische

vector<double> myVector;

Also brauche ich am Ende nichts machen?

JPSelter schrieb:

Ich habe ihn am Anfang einer Funktion deklariert:

vector<double> myVector;

Also brauche ich am Ende nichts machen?

Nein du musst nichts machen. Der D'tor wird wie bei jeder anderen Klasse aufgerfuen, wenn der scope verlassen wird.

.filmor schrieb:

Ich auch. Ich denke man darf sie schon aufrufen (es sind schließlich "nur" Methoden), nur das Objekt danach nicht mehr benutzen.

So dachte ich mir das auch.

chrische

Hallo

1310-Logik schrieb:

Destructoren dürfen nicht explizit aufgerufen werden.
Mach es besser über delete myVector, wenn Du ihn dynamisch angelegt hast.

Man darf sie wirklich nicht aufrufen? Ich dachte, dass das nur unüblich sei.

chrische

Naja was heisst dürfen?
Man darf auch Memoryleaks machen...

1310-Logik schrieb:

chrische5 schrieb:

Hallo

1310-Logik schrieb:

Destructoren dürfen nicht explizit aufgerufen werden.
Mach es besser über delete myVector, wenn Du ihn dynamisch angelegt hast.

Man darf sie wirklich nicht aufrufen? Ich dachte, dass das nur unüblich sei.

chrische

Naja was heisst dürfen?
Man darf auch Memoryleaks machen...

Für mich "nicht dürfen", dass es entweder gar nicht geht, oder zu undefinierten Verhalten führt und das ist doch nicht zwangsläufig so, wenn man den D'tor aufrufst oder täusche ich mich da.

chrische

EDIT: Oh, war beantwortet. Seid ja alle fleissig am schreiben

Selbst wenn man nach dem Aufruf das Objekt nicht mehr benutzt, hat man ein Problem. Wenn der Speicher frei gegeben wird, ruft der Compiler des Destruktor noch mal auf, was in der Regel schief läuft.

Ein expliziter Destruktoraufruf gibt den Speicher nicht frei.

Beispiel:

{
  MyClass myObject;
  myObject.~MyClass();  // hier wird der Destruktor explizit aufgerufen
}  // hier verläßt myObject seinen Scope, was bewirkt, daß der Destruktor noch mal aufgerufen wird und dann der Speicher frei gegeben wird

Und jetzt das ganze auf dem Heap:

{
  MyClass* myObjectPtr = new MyClass();
  myObjectPtr->~MyClass(); // des Destruktor wird aufgerufen, aber der Speicher wird nicht frei gegeben!
  delete myObjectPtr; // der Destruktor wird nochmals aufgerufen und dann der Speicher frei gegeben
}

Lasse ich das "delete myObjectPtr" weg, wird zwar der Destruktor aufgerufen, aber es bleibt ein Memoryleak!

Hier wird es richtig gemacht (denke ich - ich würde so etwas nie machen):

{
  MyClass* myObjectPtr = (MyClass*)malloc(sizeof(MyClass));
  myObjectPtr->MyClass(); // Konstuktor aufrufen
  myObjectPtr->~MyClass(); // Destruktor aufrufen
  free(myObjectPtr); // und Speicher wieder frei geben
}

Ich hoffe, daß das letzte Beispiel auch den letzten davon abschreckt, den Destruktor explizit aufrufen zu wollen

Tntnet

#include <new>

struct X { int y; };

int main(int argc, char* argv[])
{
	char mem[100];
	X *ary = (X*) mem;
	new (ary + 0) X;
	new (ary + 1) X;
	new (ary + 2) X;
	/* ... */

	/* delete[] ary geht schlecht, da der Speicher auf dem Stack liegt */
	(ary + 0)->~X();
	(ary + 1)->~X();
	(ary + 2)->~X();
	/* ... */
}

EDIT:
Zu lahm

/edit. Mkay, zu spät ...

MyClass* myObjectPtr = (MyClass*)malloc(sizeof(MyClass));
  new (myObjectPtr) MyClass(); // Konstuktor über placement new aufrufen
  myObjectPtr->~MyClass(); // Destruktor aufrufen
  free(myObjectPtr); // und Speicher wieder frei geben