ein beispiel:

MeinObject* aufDemHeap = new MeinObject("abc");
int x = a / b;
delete aufDemHeap;

die division a/b könnte ja fehlschlagen. wie kann ich trotzdem sicherstellen, dass meine objekt-Instanz gelöscht wird?

Das Beispiel ist meiner Meinung nach, etwas schlecht gewählt. Etwas dergleichen, würde man einfach mit einem

if(b!=0)

regeln.

Aber um auf deine Frage zurückzukommen. Der einfachste Weg wäre, einfach zu überprüfen, ob die Daten valide sind. Sind sie es nicht, wird der Codeteil schlichtweg nicht ausgeführt und es entsteht kein Fehler.

Sollte das nicht gehen, würden sich Exceptions eignen. Dabei reservierst du erst Speicher auf dem Heap, schließt den Code, der ggf eine Exception wirft, in einen try{} Block ein und fängst eine Exception mit dem catch() Block.
Einige C++ Funktionen werfen selbstständig Exceptions, zB "new". Bei anderen musst du dann selbst dafür sorgen, dass eine Exception geworfen wird.

zB

MeinObject *aufDemHeap = new MeinObject("abc");
try
{
    x=a/b;
    if(x==std::numeric_limits<float>::infitive 
        || x==-std::numeric_limits<float>::infitive) 
    throw new Exception("Fehler beim dividieren");

    std::cout << x;
    delete aufDemHeap;
}
catch(Exception e)
{
   std::cout << e;
   delete aufDemHeap;
}

Allerdings ist es üblich, alles vorhersehbare (wie eine Division durch 0), vorher aufzuhalten, damit solche Fehler erst gar nicht entstehen. Exceptions dienen dann mehr für "unvorhersehbare" Ereignisse oder wenn die Fehlerbehandlung an einem anderen Ort geschehen soll.


//Edit: Fehlerhaften Code korrigiert.

Bei der Antwort von Shelling rollen sich mir ja beinahe die Fußnägel hoch. Die ist so nicht skalier-/ und wartbar.

Eine bessere Lösung wäre, das RAII-Prinzip zu nutzen. Das geht zum Beispiel mit dem Shared Pointer von boost.

Der Code sähe dann in etwa so aus:

boost::shared_ptr<MeinObject> aufDemHeap(new MeinObject("abc"));
int x = a / b;
aufDemHeap->TueIrgendwas();

Das Objekt wird dann automatisch gelöscht, sobald der Block verlassen wird. Bei einer Division durch 0 sieht's aber sowieso ziemlich übel aus. Sinnvoller ist das Ganze bei C++ - Exceptions.

Gruß,

Andre

EDIT: Der Boost Shared Pointer ist nur ein Beispiel. Den mehrfach hier erwähnten std::auto_ptr kann man natürlich leichter benutzen (man muss keine Bibliothek einbinden). Eine weitere Möglichkeit besteht übrigens darin, eigene Klassen zu definieren, die im Konstruktor das new und im Destruktor das delete machen.

andre's Antwort ist im Prinzip richtig, es geht aber auch ohne eine zusätzliche Library wie Boost (die aber natürlich dennoch empfehlenswert ist...), es gibt in der normalen C++-Standard-Template-Library dafür das Klassentemplate auto_ptr:

#include <memory>

...

std::auto_ptr<MeinObject> aufDemHeap(new MeinObject("blub"));
int x = a / b;
aufDemHeap->machWas();

Ein Problem ensteht bei den harten Exceptions sowieso. Seit dem Visual Compiler 2005 landet man nicht unbedingt im catch block sondern das Programm wird beendet.

Ich stimme meinen Vorrednern zu das man solche Problem am besten gar auftreten lassen sollte. Ist wie im Handwerk wenn ich ein Brett zu kurz gesägt habe ist es zu kurz und so weit sollte man es gar nicht erst kommen lassen.

MeinObject* aufDemHeap = new MeinObject("abc");
if ( b == 0 )
   std::cout << "division durch 0!\n"
else
    int x = a / b;
delete aufDemHeap;