Pointer rumgereicht und dann gelöscht

Ich kann doch einen Pointer auf ein Objekt in der Gegend "rumreichen" (auch zwischen Klassen) und später aber immer delete aufrufen, ohne Angst haben zu müssen, Speicherlöcher zu erzeugen. Oder?

void function()
{
    Objekt_A* derPointer = new Objekt_A();
    loesche(derPointer);
    derPointer = NULL;
    // Speicher sauber, oder?
}

...

void loesche(Objekt_A* temp)
{
    delete temp;
    temp = NULL;
}

Richtig.

Speicherlöcher entstehen, wenn du bei dem ganzen Rumgereiche vergisst, den Speicher wieder freizugeben.

Deshalb ist es empfehlenswert, die Verantwortlichkeit für die Freigabe dem auzuerlegen, der den Speicher reservierte.
Also demselben Objekt (Kon/Destructor) oder wenigstens möglichst nahe im Quelltext.

Das

temp=NULL

in der lösche Function bringt übrigens nix, denn die temp ist nur lokal in der Funktion vorhanden.

Linuxpower

Nur warum kann man nach einer delete Anweisung immer noch auf die Objekte zugreifen?

Hier mein Beispiel:

#include <iostream>
using namespace std;	

int main()
{
	int x;
	long *lptr = new long[10];

	for(x = 0; x < 10; ++x)
		lptr[x] = x;

	delete[] lptr;

	for(x = 0; x < 10; ++x)
		cout << lptr[x] << "  ";
	cout << endl;

	for(x = 0; x < 10; ++x)
		lptr[x] = x + 10;

	for(x = 0; x < 10; ++x)
		cout << lptr[x] << "  ";
	cout << endl;

	return 0;
}

Bei mir erfolgt die ausgasbe:
0 1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19

Doch das dürfte doch eigentlich gar nicht sein oder? Denn der Speicher wurde doch schon vorher wieder freigegeben. Aber trotzdem ist es möglich den Speicherbereich zu lesen und sogar zu beschreiben. Ich bin jetzt doch etwas verwirrt.

evilissimo

Das nennt sich undefiniertes Verhalten. Es kann sein das der Speicher an der Adresse noch nicht überschrieben wurde und du kannst deshalb noch drauf zugreifen. Nur du kannst dich nicht drauf verlassen das es immer und überall ( auf allen Systemen ) so ist. ( Edit: Bzw kann das natürlich auch von Programmausführung zu Programmausführung anders sein )

BR
evilissimo