Sprachkonzepte Preprozessor Operatoren Kontrollstrukturen Typen OOP

try-catch

Die try-catch-Struktur ist nur in C++ definiert und erlaubt dem Programmierer, Exception-Handling zu betreiben. Dabei wird nach dem try-Keyword ein Anweisungsblock definiert, welcher den regulären Programmverlauf beinhaltet. Nach diesem Block können ein oder mehrere catch-Blöcke definiert werden, welche jeweils einen eindeutigen Typ erwarten und ein passendes Exception-Handling beinhalten. Tritt irgendwo innerhalb des try-Blockes während der Ausführung des Programmes eine ungewollte Situation auf, kann der Programmierer mittels dem throw-Operator eine Ausnahmebehandlung erzwingen, womit augenblicklich zu dem entsprechenden catch-Teil gesprungen und die Ausführung dort fortgesetzt wird.

#include <stdio.h> void openfile(){ FILE* file = fopen("notexistingfile.txt", "r"); if(!file){throw "Could not open file!";} } int main(){ try { openfile(); } catch(const char* e){ printf("An error occured:\n%s\n", e); } return 0; }

An error occured: Could not open file!

Siehe auch catch, throw, ... (catch-all)

Details

Es ist möglich, mehrere catch-Blöcke zu definieren. Wenn innerhalb des try-Blockes keine Exception auftritt, so werden am Ende des try-Blockes alle catch-Blöcke übersprungen und mit der ersten Anweisung nach der try-catch-Struktur fortgefahren. Wenn eine Exception auftritt, so wird der entsprechende Handler angesprungen und die Programmausführung dort fortgesetzt. Nach Abarbeitung des Handlers wird nicht zur aufgetretenen Exception zurückgesprungen, sondern an die erste Anweisung nach der try-catch-Struktur.

Es ist möglich, try-catch-Strukturen ineinander zu verschachtelt. Insbesondere ist möglich, innerhalb eines catch-Blockes eine weitere Exception mittels dem throw-Operator zu erzwingen, die dann möglicherweise in einer anderen try-catch-Struktur abgefangen wird.

Die try-catch-Struktur verwendet das Runtime-System, um bei Auftreten einer Exception den Programmablauf geordnet fortzuführen. Der Ablauf einer Ausnahmebehandlung geht folgendermassen vonstatten: Das runtime-System ermittelt den Typen der Exception und sucht sich ausgehend vom aktuellen Programmstatus die erste zum Typ passende Behandlungs-Routine, indem es rückwärts durch den Callstack sucht. Solange die passende Behandlungsroutine nicht gefunden wird, geht die Suche auf dem nächst tieferen Funktions-Level weiter. Wenn bis zum Schluss keine passende Routine gefunden wird, so wird dem Programm das Abort-Signal 6 gesendet, was ohne explizite Abfangung zur Terminierung des Programmes führt.

Wenn jedoch eine Behandlungsroutine gefunden wird, so wird das beim throw-Operator angegebene Objekt in den Parameter der Routine geschrieben. Danach wird vom momentanen Programmstatus aus sukzessive der Call-Stack abgebaut und sämtliche auto-Variablen dealloziiert bis zur Funktion, in der die Behandlungsroutine definiert ist. Sodann wird der Programmablauf an der gefundenen Routine fortgeführt.

Exception-Klassen

Die try-catch-Struktur arbeitet mit Typen, die durch das Runtime-System evaluiert werden. Dadurch ist es möglich, Exception-Klassen zu definieren.

#include <stdio.h> class Error{ public: void printMessage(){ printf("An error occured."); } }; void openfile(){ FILE* file = fopen("notexistingfile.txt", "r"); if(!file){throw Error();} } int main(){ try{ openfile(); }catch(Error& e){ e.printMessage(); } return 0; }

An error occured.

Mittels Polymorphie können nun abgeleitete Klassen von dieser Basisklasse erstellt werden. Diese vererbten Klassen werden vom Laufzeitsystem erkannt und dienen als spezialisierte Exception-Objekte.

#include <stdio.h> class Error{ public: virtual void printMessage(){ printf("An error occured."); } }; class FileNotFoundError : public Error { public: virtual void printMessage(){ printf("File not found."); } }; void openfile(){ FILE* file = fopen("notexistingfile.txt", "r"); if(!file){throw FileNotFoundError();} } int main(){ try{ openfile(); }catch(Error& e){ e.printMessage(); } return 0; }

File not found.

Es sei hier angemerkt, dass für solche Exceptions das Runtime-Type-Information (RTTI) benötigt wird. Allerdings ist es bei manchen Compilern (wie beispielsweise bei GCC) nicht notwendig, dasselbe extra zu aktivieren, da die benötigten Strukturen bei Bedarf und nur wo nötig automatisch generiert werden.

Die Standardbibliotheken von C++ definieren bereits einige Exception-Klassen, die sich mittels Einbindung der <exception>-Bibliothek verwenden und erweitern lassen. Auf eine ausführliche Beschreibung dieser Klassen wird jedoch momentan verzichtet (siehe auch Schlussbemerkung unten).

Handhabung des Übergabeparameters

Der Parameter wird vor dem Löschen des Call-Stacks der Behandlungs-Routine übergeben. Wenn die Behandlungs-Routine einen Value-Parameter erwartet, wird hierbei der Inhalt der Variablen direkt in den Parameter kopiert.

Wenn die Routine jedoch eine Referenz erwartet, gibt man als Exception-Objekt einen Konstruktor an. Der throw-Operator ruft implizit ein new auf, welches das Objekt im Heap alloziiert und übergibt die Referenz darauf der Routine. Am Ende der Routine wird implizit ein delete auf dieses Objekt aufgerufen, damit der Speicher wieder sauber ist.

#include <stdio.h> #include <cstring> class error{ public: char* message; error(){ message = new char[16]; strcpy(message, "Errormessage");} ~error(){ printf("Dealloc called\n"); delete message;} }; void openfile(){ FILE* file = fopen("notexistingfile.txt", "r"); if(!file){throw error();} } int main(){ try{ openfile(); }catch(error& e){ printf("An error occured: %s\n", e.message); } return 0; }

An error occured: Errormessage Dealloc called

Aufgrund der impliziten new- und delete-Operationen sollte man bei catch-Definitionen mit Referenz immer einen throw-Operator mit einem Konstruktor als Exception-Objekt angeben, nicht ein bereits existierenden Objekt. Andernfalls ruft der throw-Operator mangels besseren Wisens einen Standardkonstruktor des Exception-Typs auf und ruft den Copy-Operator auf, um die Werte des gegebenen Objektes in diejenigen des soeben alloziierten zu übertragen. Durch die implizite delete-Operation passiert es somit, dass das Objekt mehrfach dealloziiert wird:

error globalerror; void openfile(){ FILE* file = fopen("notexistingfile.txt", "r"); if(!file){throw globalerror;} }

An error occured: Errormessage Dealloc called Dealloc called Deallocation of a pointer not malloced

Schlussbemerkung

Während Exception-Handling in vielen modernen Sprachen ein unverzichtbarer Teil für geordnete Programmabläufe darstellt, ist dessen systematische Verwendung in C++ kaum bekannt. Die verschiedenen Quellen drücken sich vor genauen und ausführlichen Angaben über das Verhalten dieses Konstrukts. Die Ermittlung von erklärbaren Phänomenen in der Welt des Exception-Handlings ist äusserst mühsam, weswegen der Autor sich hier als fauler Sack outet und das Thema vorerst abschliesst.