Hallo zusammen,

Habe ein Verständnisproblem mit den lieben Zeigern. Das ganze tritt in einem etwas komplexeren Zusammenhang auf , aber ich hab es reduziert auf dies einfache Beispiel, welches mein Verständnisproblem gut erklärt.

Situation: ich hab 'nen Zeiger, übergebe ihn an eine Funktion, gebe dort den Speicherplatz frei. Wie kann ich jetzt sicherstellen, dass ich in der aufrufenden Funktion mitbekomme, das der Platz schon freigegeben wurde?

Also, folgendes Beispiel endet mit einem ganz üblen Segmentation fault, da er versucht ein delete auf y auszuführen:

#include <unistd.h>

#include <stdio.h>


void testdel(int *x)

{

  if (x!=NULL) delete x; 

  x=NULL;

};


int main ( int argc, char** argv){

  int *y= new int(5);

  testdel(y); 

  if (y!=NULL) {

    delete  y; 

    y=NULL;

  } 

}

Mein Problem ist nun das ich nicht wirklich bis in die Tiefe verstehe, WIESO es knallt:

Denn ich habe mit *y einen Zeiger definiert, den ich mit y übergebe und in der Funktion als x verändern darf, mithin auch den Speicherplatz freigeben, (soweit funktioniert es ja auch) aber dann muss es doch auch möglich sein, mit x=NULL oder mit *x=NULL, der aufrufenden Funktion irgendwie mitzuteilen, dass y jetzt NULL ist.

Wenn das so nicht geht, dann muss es doch zumindest irgendeine Prüfung für y oder *y oder was auch immer geben, welche mir sagt, ob da noch Speicherplatz belegt wird, der freigegeben werden muss. Wie gesagt, die Prüfung im main -Programm wie oben implementiert, geht leider schief - WARUM bzw. wie kann ich das ändern?

vielen Dank,

ragosti

PS: ich denke, ich brauche eine Lösung, die ohne Pointer auf Pointer auskommt....

Wie gesagt, die Prüfung im main -Programm wie oben implementiert, geht leider schief - WARUM bzw. wie kann ich das ändern?

Weil du y nicht veränderst, das zeigt nach deinem Funktionsaufruf immer noch auf die nicht mehr gültige Speicheradresse.

So gehts zum Beispiel:

#include<stdio.h>


void testdel(int **x)

{

  if (*x!=NULL) delete *x; 

  *x=NULL;

};


int main ( int argc, char** argv){

  int *y= new int(5);

  testdel(&y); 

  if (y!=NULL) {

    delete  y; 

    y=NULL;

  } 

}

[/PHP]

Weil du y nicht veränderst, das zeigt nach deinem Funktionsaufruf immer noch auf die nicht mehr gültige Speicheradresse.

So gehts zum Beispiel:

#include<stdio.h>


void testdel(int **x)

{

  if (*x!=NULL) delete *x; 

  *x=NULL;

};


int main ( int argc, char** argv){

  int *y= new int(5);

  testdel(&y); 

  if (y!=NULL) {

    delete  y; 

    y=NULL;

  } 

}

[/PHP]

Danke @Guybrush Threepwood für die schnelle Antwort, aber - damit bin ich noch nicht so ganz zufrieden dass es mit pointer auf pointer grundsätzlich geht, war mir schon klar, aber - wie gesagt, wenn ich Deinen Ansatz mal versuche in mein komplexes Problem zu integrieren, dann geht diese Variable über mehrere Ecken und müsste dann immer weiter referenziert werden??? Also hier mal eine Skizze von dem was ich meine:

[code] #include <unistd.h> #include <stdio.h> void testdel2(int ***x) { if (**x!=NULL) { delete **x; **x=NULL; } }; void testdel(int **x) { testdel2(&x); if (*x!=NULL) { delete *x; *x=NULL; } }; int main ( int argc, char** argv){ int *y= new int(5); testdel(&y); if (y!=NULL) { delete y; y=NULL; } } [/code]

jede weitere Übergabe wäre mit einem weiteren Sternchen zu realisieren (testdel3(int ****int x) usw. ) , da hänge ich dann irgendwann mit 10 Sternchen rum, und hab wirklich endgültig keinen Überblick mehr, daher meine Frage kann man denn in dem ursprünglichen Code nicht doch irgendwie im main herauskriegen ob der Speicher freigegeben wurde? Oder mache ich einen anderen Denkfehler - oder irgendwas anderes grundsätzlich falsch? denn irgendwo hab ich eine Aussage im Hinterkopf dass mehr als zwei * eigentlich in keiner denkbaren Situation Sinn machen - aber anders hab ich das oben nicht gelöst bekommen...

ragosti

jede weitere Übergabe wäre mit einem weiteren Sternchen zu realisieren (testdel3(int ****int x) usw. ) , da hänge ich dann irgendwann mit 10 Sternchen rum, und hab wirklich endgültig keinen Überblick mehr,

Du musst keinen Zeiger auf ein Objekt übergeben, um es in der Funktion ändern zu können. Es gibt auch Referenzen. Dein Code sieht ein wenig danach aus, als ob du eigentlich in C programmierst, und nur statt malloc/free mit new/delete arbeitest.

kann man denn in dem ursprünglichen Code nicht doch irgendwie im main herauskriegen ob der Speicher freigegeben wurde? Oder mache ich einen anderen Denkfehler - oder irgendwas anderes grundsätzlich falsch?

Ich würde sagen, letzteres.

Du solltest gar nicht wissen müssen, ob ein Zeiger noch auf gültigen Speicherbereich zeigt. Du solltest nach Möglichkeit gar nicht mit rohen Zeigern hantieren - Stichwort RAII.

In C++ hat man ganz andere Möglichkeiten, so etwas zu lösen. Da gibt es Container und Smartpointer. Zeiger braucht man in C++ eigentlich nur selten.

Hallo,

daher meine Frage kann man denn in dem ursprünglichen Code nicht doch irgendwie im main herauskriegen ob der Speicher freigegeben wurde?

In C ist das nicht so ganz einfach. Eine Möglichkeit wäre die Verwendung einer eigenen Speicherverwaltung, die auf malloc/free aufbaut.

Gruss

Nic