Pointers über Pointers ;-)

ich habs so verstanden, bsp:
speicher: 0123456789
element der "mutterliste" zeigt auf 0
element der "kindliste" auf 3

afair:
wenn du jetzt free(element "mutterliste") aufrufst, dann ist 0-9 weg.

wenn du dann auf den bereich, auf den das element der "kindliste" zeigt, zugreifst, erhältst du eine speicherverletzung.

x *ptrX = new x();

y *ptrY = new y();
ptrY->ptrX = ptrX;

delete ptrX;

ab jetzt ist ptrY->ptrX undefiniert, d.h. bei Verwendung dessen kann es zu einer Speicherverletzung kommen, wie schon west erläutert hat. Der prtY->ptrX zeigt quasi irgendwohin. Wenn du ptrY->ptrX freigibst wird auch der Speicher von ptrX freigeben. Eine Freigabe könnte so aussehen:

ptrY->ptrX = NULL;
delete ptrX;
ptrX = NULL;
delete ptrY;
ptrY = NULL;

von c weiss ichs, von c++ nicht (wird aber vermutlich genauso sein):

free() auf einen pointer gibt den dahinterliegenden speicher frei. free() lässt sich nur auf einen pointer anwenden, der von malloc(), calloc() oder realloc() zurückgegeben wurde. soweit so gut.
der pointer selbst wird bei free() NICHT auf null gesetzt. (das geht bei c überhaupt nicht. -> Stichwort "call by value").
free() hat auch keinen return value. afair: bei free() kann man von erfolgreicher durchführung ausgehen.

(die "nice code"-konvention sagt, dass man nach einem free() den pointer auf null setzen soll. vorteil: wenn nochmal free() aufgerufen wird, passiert nichts.)

> man 3 free

Zitat

DESCRIPTION
free() frees the memory space pointed to by ptr, which must have been returned by a previous call to
malloc(), calloc() or realloc(). Otherwise, or if free(ptr) has already been called before, unde-
fined behaviour occurs. If ptr is NULL, no operation is performed.

Zitat

RETURN VALUE
free() returns no value.

Zitat von sommeralex

wenn ich

free(head_alarm);

if(head_alarm == NULL){

printf("freed!\n");

}

mache, komme ich dennoch nicht in freed!.. warum?

Alles anzeigen

Weil head_alarm nicht NULL ist. Wie schon erwähnt zeigt er irgendwo hin.

der pointer selber gehoert noch dir. der referenzierte bereich aber nicht mehr und kann dir vom OS jederzeit weggenommen werden, d.h. man produziert nicht in allen faellen eine speicherverletzung. (manche OS räumen erst auf, wenn der platz benötigt wird. manche sofort. voodoo.)

Zitat von sommeralex

vielen dank einmal für die antworten. es wundert mich nur, dass ich obwohl ich free(head_alarm) schreibe, "danach" immer noch auf head_alarm zugreifen kann!

Bei kleineren Allozierungen reserviert malloc meistens gleich einen größeren Block, und returnt aus diesem Block heraus Speicherplätze wenn noch mehr Platz ist drinnen. Dadurch wird der overhead kleiner gehalten.
Dieses Verhalten ist allerdings nicht genauer spezifiziert, und man kann sich daher nicht drauf verlassen (weder zwischen OS, noch zwischen Computern, nichtmal zwischen Mondphasen am gleichen Computer).

Zitat von sommeralex

wenn ein struct X auf andere structs Y zeigt, und ich dieses struct X mit free(struct X) anschreibe, werden dann auch meine structs Y "gelöscht"/free - obwohl noch andere zeiger auf diese zeigen?

Generell wird nichts gelöscht, was du ihm nicht sagst. Dir kanns auch passieren, dass du Speicher reserviert hast, auf den du keinen Pointer mehr hast, das ist dann ein memory leak.
C und C++ haben per default keine garbage collection wie Java, Haskell und andere Sprachen!

Am besten ist es, wenn du Pointer als normale Variablen ansiehst, die eine Speicheradresse als Inhalt haben (was ja auch wirklich der Fall ist). malloc() reserviert einen Block im Speicher und gibt die Anfangsadresse zurück. Irgendwann musst du genau diese Anfangsadresse wieder free() übergeben, dann wird der komplette Block wieder freigegeben. Mehr Magie passiert nicht (aus der Sicht des Programmierers).

Zitat

aber wie lösche ich nun "nur" die zeiger? (ohne die objekte zu löschen, auf die sie zeigen)

meinzeiger = NULL;

was äquivalent ist zu meinevariable = 0; bei Integer-Typen.

Zitat von sommeralex

ich möchte nun zusätzlich noch eine liste, aus struct y (und struct y enthält struct x zeiger, diese zeigen alle auf die vorher schon erstelle liste bzw. objekte meiner liste)

muss ich diese liste über ein malloc initiieren? oder nicht? die zeiger, auf die dieses struct y zeigen, sind alle schon über ein malloc erzeugt worden.

Generell ist der Inhalt des Speicherbereichs völlig egal. free schaut sich nicht an, was da drinnen liegt (und für free selber ist es ja nur ein Haufen von Bytes ohne Bedeutung).

Zitat

wenn ich nun struct y "free" befehle, wirkt sich dass auch auf meine liste x aus?

Gar nicht.

Zitat

wenn ich die struct y liste über malloc initiiert habe, muss ich sie ja mit free loswerden.

Richtig.

Zitat

vielleicht muss ich aber gar nicht diese liste über ein malloc deklarieren, oder?

Naja, irgendwoher muss der Speicher kommen, wo du das hinspeicherst. Speziell in C++ gibts da viele andere Methoden, aber in C greift man bei sowas eigentlich immer auf malloc zurück.

Zitat von sommeralex

kann es vielleicht sein, dass ich nur den "speicher meines pointers" über free loswerden muss? also free(&pointer) ???

nur wenn du den Speicher deines Pointers vorher alloziert hast mit malloc, also sowas in der Art wie &pointer = malloc(sizeof(&pointer));. Das geht aber nur in C++ mit seinen Referenzen.

Du verwechselst den Speicherplatz, den der pointer selber beansprucht mit dem, auf den er zeigt. Ein Pointer ist eine Datenstruktur, die üblicherweise 4 Byte groß ist (auf 16bit-Systemen 2 Byte, auf 64bit-Systemen 8 Byte, etc). Auch dafür muss man Speicher reservieren.

Nochmal: Stell dir vor da würde kein Pointer stehen, sondern ein int. Dann verwirrt es dich vielleicht weniger

Vielleicht hilft es dir, wenn du einen passenden Debugger hernimmst und dir die Werte und Speicherbereiche anzeigen lässt. Ein selbstgetesteter Code sagt mehr als tausend Worte.