C++ dynamisch erzeugtes Objekt freigeben?

[PrototypePHX]

Hi,

ich erzeuge in C++ mit dem new-Operator automatisch Objekte. Müssen diese dann wieder deleted werten? Also praktisch im Destruktor

delte this;

?

MfG

 

[little_skunk]

ich erzeuge in C++ mit dem new-Operator automatisch Objekte. Müssen diese dann wieder deleted werten?

Ja müssen sie sonst ist irgendwann der Speicher voll.

Also praktisch im Destruktor

delte this;

?

Rhethorische Frage: Mit welchem Befehl ruft man den Destruktor auf?

 

[PrototypePHX]

Hmm irgendwie steh ich grad voll aufm Schlauch
Wird das Objekt also automatisch gelöscht wenn sein Destruktor aufgerufen wird? Selbst wenn ich es mit dem new - Operator erstellt hab?

 

[-=DFY=-]

Nein, das Objekt wird geloescht (genauer gesagt, der Speicher wird freigegeben) wenn du

delete Objekt;

machst. Der Destruktor ist dazu da, dass du weitere Dinge angeben kannst, die gemacht werden muessen bevor das Objet stirbt. Beispiel:

class Auto {

 Sitz s1, s2;
 Auto() {
   s1 = new Sitz();
   s2 = new Sitz();
 }

 ~Auto() {
   delete s1;
   delete s2;
 }
}

int main(int argc, char** argv) {
   porsche = new Auto();
   //irgendwas
   delete porsche;
}

Wenn du jetzt den Destruktor nicht haettest, wuerde durch "delete porsche;" zwar der Speicher freigegeben werden, der durch das Auto-Objekt belegt ist, aber die Sitz-Objekte wuerden nicht freigegeben werden und der Speicher waere solange verloren bis das Programm beendet wird.

 

[little_skunk]

Im Destruktor darf aber niemals delete this stehen. Der Destruktor wird nur dann aufgerufen wenn irgendjemand anders ein delete befehl für dieses Objekt abschickt. Wenn es im gesammten Programm nur im Destruktor einen delete befehl für dieses Objekt gibt, wird das niemals nie aufgerufen werden. Wenn es von außerhalb ein delete Befehl gibt, brauchst du delete this sowieso nicht mehr machen. Das ist dann ja schon längst angestoßen worden. Was in den Destruktor gehört kannst du dem wunderschönen Beispiel über mir entnehmen.

 

[PrototypePHX]

Ich glaub du hast meine Frage falsch verstanden. Also mal konkreter:
Ich habe einen Pointer auf ein Array aus Objekten, die dann später in einer Schleife mit dem new-Operator angelegt werden.

  tty *ttyDev[maxdev];

  /* starting with 1 for argv since parameter #0 is filename */
  for (int i = 1; i < argc; ++i)
      ttyDev[i-1] =  new tty(argv[i], O_RDWR | O_NOCTTY | O_NONBLOCK, i-1);

Wenn ich jetzt wieder deren Speicher freigeben will, muss ich das außerhalb der Klasse in einer Schleife mit delete machen, oder kann ich direkt im Destruktor "delete this;" schreiben?
Ich habs getestet, es kompiliert und funktioniert jedenfalls.

EDIT: Bezog sich DFYs Post

 

[little_skunk]

Weder noch. Du musst im Destruktor delete Array und nicht delete this machen.

Den Destruktor der Klasse musst du dann gegebenfalls von außerhalb mit delete xy aufrufen.

 

[-=DFY=-]

Ich glaub du hast meine Frage falsch verstanden. Also mal konkreter:
Ich habe einen Pointer auf ein Array aus Objekten, die dann später in einer Schleife mit dem new-Operator angelegt werden.

  tty *ttyDev[maxdev];

  /* starting with 1 for argv since parameter #0 is filename */
  for (int i = 1; i < argc; ++i)
      ttyDev[i-1] =  new tty(argv[i], O_RDWR | O_NOCTTY | O_NONBLOCK, i-1);

Wenn ich jetzt wieder deren Speicher freigeben will, muss ich das außerhalb der Klasse in einer Schleife mit delete machen, oder kann ich direkt im Destruktor "delete this;" schreiben?
Ich habs getestet, es kompiliert und funktioniert jedenfalls.

EDIT: Bezog sich DFYs Post

Du musst das definitiv ausserhalb der 'tty'-Klasse machen. Der Destruktor der 'tty'-Klasse wird in deinem Beispiel naemlich nie aufgerufen. (Destruktoren werden nur durch delete aufgerufen, oder wenn eine Objektvariable aus dem Scope faellt (nicht aber eine Pointervariable).)

Bin nicht ganz sicher wo sich der Code befindet den du gepostet hast. Wenn der in 'ner Klasse namens XYZ bist, kannst du natuerlich im Destruktor von XYZ die ttys wieder freigeben, musst das aber mit ner Schleife machen wo du jedes einzelne tty deletest.

 

[little_skunk]

Delete this im Destruktor ist einfach kompletter schwachsinn. Dürfte sogar auf eine Endlosschleife hinauslaufen wenn der Destruktor denn überhaupt jemals aufgerufen wird.

 

[PrototypePHX]

Kompletter Schwachsinn ist es nicht, es kompiliert und spuckt keine Fehler aus. Wahrscheinlich ist es nur normaler Schwachsinn

 

[-=DFY=-]

Keine Fehler ausspucken tut es aber nur weil es nie aufgerufen wird. Wenn du versehentlich mal ein Objekt von ausserhalb deletest, was im Destruktor "delete this" stehen hat, stuerzt das Programm wegen Segfault ab oder macht eine Endlos-Destruktorschleife wie von little_skunk vorhergesagt (hab's gerade getestet) .

 

[little_skunk]

Danke für den Test. War mir da nicht sicher. Jetzt hab ich auch was dazugelernt

 

[-=DFY=-]

@ProrotypePHX: Ist deine Frage damit geklaert? Wuerde mich schlecht fuehlen wenn wir jetzt ne Diskussion ueber die Details starten und du deine Antwort noch nicht hast

Falls es noch von Interesse ist: Es ist tatsaechlich eine Endlosschleife, die auftritt. Der Segfault ist eine Konsequenz davon, wenn die Rekursionstiefe zu gross wird (auf meinem System, Linux 2.6, 2GB RAM, stuerzt es bei ner Rekursionstiefe von circa 260000 ab). Wundert mich etwas, haette fuer den Fall eher mit einem stack overflow gerechnet.

 

[PrototypePHX]

Ja, ist geklärt, danke

 

[.K.I.L.L.U.A.]

sorry wenn ich die leiche ausgrabe °.^

tip:
schau dir mal die boost smart pointer an die auch in tr1 sind !

shared_ptr - Boost 1.46.1
shared_array - Boost 1.46.1