ich muss vorrausschicken, ich komme ursprünglich von der Java-Programmierung und lese gerade das hervorragende Buch "Effective C++" von Meyers.
Daher beschäftige ich mich mit der Speicherverwaltung.

Habe nun folgende Verständnisfrage:
Ich habe eine Klasse mit einer konstanten Methode:

TestClass.h :

class TestClass
{
public:
	TestClass();
	~TestClass();
	const void doOutput();
};

TestClass.cpp :

#include <iostream>

const void TestClass::doOutput(){
	std::cout << "Miau!";
}

Und hier die main.cpp:

int main()
{
	TestClass *ptr = new TestClass();
	ptr->doOutput();
	delete ptr;
	ptr = 0;
	ptr->doOutput();
	return 0;
}

Was mich völlig umhaut, ist dass das nicht nur klaglos kompiliert wird, sondern sogar läuft (Zweimal Miau! in der Konsole) unter Windows mit MSVC++, unter Windows mit gcc 3.x von MinGW und unter Linux mit gcc 4.2.1.
Dass delete den Speicher nur freigibt und da nix passiert, solange nichts neues geschrieben wird, ist mir klar. Aber wenn der Zeiger genullt wird, rufe ich doch dann praktisch null.doOutput() auf, und das kann doch nicht gehen?
Dass c++ keine runtime-exceptions macht, daran habe ich mich ja mittlerweile gewöhnt, aber das sowas klaglos kompiliert wird, wundert mich doch arg!

Ist das ein undefiniertes Verhalten oder liegt das an wohlwollenden Kompilern?

Gruß,
Philipp

Dass delete den Speicher nur freigibt und da nix passiert, solange nichts neues geschrieben wird, ist mir klar. Aber wenn der Zeiger genullt wird, rufe ich doch dann praktisch null.doOutput() auf, und das kann doch nicht gehen?

Das hatte ich auch mal. Das liegt daran, dass du keine Daten hast und auch keine manipulierst in der Member Funktion. Darum kann der 0-Zeiger ohne weiteres einfach etwas ausgeben. Wenn du jetzt mal Daten miteinbeziehst, wird es nicht mehr gehen.

foo.bar();
ist nur eine andere Schreibweise fuer bar(&foo);

Und wenn bar nun nie auf foo zugreift, kommt es nie zu einem Fehler.

Natuerlich ist das nicht garantiert - wenn naemlich bar() Debug Infos schreiben will, dann kann das Programm leicht abstuerzen - oder wenn sonst wie auf foo zugegriffen wird.

Das ist das tueckische an Zeigern: nur weil das Programm laeuft muss es noch lange nicht korrekt sein.

Wenn du jetzt mal Daten miteinbeziehst, wird es nicht mehr gehen.

Jop das hab ich gerade ausprobiert. So macht das Sinn. Auch die Erklärung von Shade of Mine ist einleuchtend.

Habe jetzt mal eine private int count und eine get-Methode für diese eingeführt.
Jetzt stellt sich mir nur die Frage: Warum das

int main()
{
	TestClass *ptr = new TestClass(234);
	int i=0;
	ptr->doOutput();
	cout << ptr->getCount();
	delete ptr;
	ptr = 0;
	try {
		ptr->doOutput();
		i = ptr->getCount();
	}
	catch(...){
		cout << "Fehler!";
		i = 4711;
	}
	cout << i;
	return 0;
}

Zu einer unbehandelten Ausnahme "Zugriffsverletzung beim lesen an position 0x00" führt, also der klassischen NullPointerException, um mal im Java-Jargon zu reden.
Warum wird die von catch() nicht gefangen und "Fehler" ausgegeben?