Programmieren - C++ Ausnahmebehandlung

Transkript

1 Programmieren - C++ Ausnahmebehandlung Reiner Nitsch 8417 r.nitsch@fbi.h-da.de

2 Übliche Fehlersituationen (meist in aufgerufenen Funktionen) Teilen durch 0 (Null) Vorbedingungen nicht erfüllt Indexbereich bei Arrays überschritten Kein Speicher mehr bei new (kommt noch) Formatfehler bei Eingaben Fehler bei Dateioperationen Zugriff auf nicht geöffnete Datei Datei kann nicht geöffnet werden Speichermedium voll Probleme im Fehlerfall: Bibliotheksfunktionen können Laufzeitfehler entdecken. Die angemessene Reaktion darauf kennt aber nur die aufrufende Instanz. Die aufrufende Instanz kennt die angemessene Reaktion auf Fehler. Sie ist jedoch nicht in der Lage, sie zu entdecken C++ Ausnahmebehandlung 2

3 Traditionelle Fehlerbehandlungsstrategien 1. Fehler ignorieren 2. Das Programm terminieren (assert oder exit) 3. Einen Wert zurückliefern, der "Fehler" anzeigt (z.b. eine globale Fehlervariable oder einen Funktionsparameter/Rückgabewert) Der Indikator muss nach jedem Aufruf abgefragt werden, unabhängig davon, ob tatsächlich ein Fehler vorliegt. Fehler können oft nicht dort behandelt werden, wo sie auftreten. 4. Eine Funktion aufrufen, die für die Fehlerbehandlung vorgesehen ist. Diese sollte genügend Informationen übergeben bekommen, um den Fehler beheben und den Programmlauf fortsetzen zu können. Bei nicht behebbarem Fehler das Programm mit einer aussagefähigen Meldung abbrechen. 5. Der Mechanismus der C++ Ausnahmebehandlung ist eine Alternative zu diesen traditionellen Techniken, wenn diese ungenügend, unelegant und fehleranfällig sind. Er trennt Fehlerbehandlungscode von "normalem" Code. Das Programm bleibt lesbarer C++ Ausnahmebehandlung 3

4 Beispielanwendung - Notenspiegel #include "ExamResult.h" #include <iostream> using namespace std; void showmenu(); int main(){ ExamResult mathexam; int item=0; while(true) { do { // Eingabeschleife: fehlertolerant showmenu(); cin.clear(); cin.sync(); cin >> item; if( cin.good() ) break; else { cout << "ERROR: nur ganze Zahl zulaessig!" << endl << " Eingabe geloescht... " << endl << endl; while( true ); switch( item) { case 1: mathexam.recordonemarkfromconsole(); break; case 2: mathexam.show(); break; void showmenu() { cout << "1 Noten erfassen" << endl << "2 Notenspiegel ausgeben" << endl << "3 Durchschnittsnote berechnen und ausgeben" << endl << "9 Programm beenden" << endl << endl << "Bitte waehlen: "; // Fehlererkennung // und Fehlerbehandlungscode // sind hier vermischt am gleichen Ort // -> unübersichlich aber hier angemessen // Fehlererkennung und Fehlerbehandlung // sind hier vermischt am gleichen Ort // -> hier auch angemessen case 3: cout << endl << "Durchschnittsnote: " << mathexam.mean() << endl; break; case 9: return 0; default: cout << "ERROR: nur 1, 2, 3, 9 zulaessig!" << endl << endl; //end switch //end while(true) // Fehlerbehandlung C++ Ausnahmebehandlung 4

5 Beispielklasse ExamResult class ExamResult { enum {MAX_M = 5; int marklist[max_m]; public: ExamResult(); ~ExamResult(); void recordonemarkfromconsole(); void show(); float mean(); void setmarkcount( int mark, int val ); int getmarkcount( int mark ); ; void ExamResult::recordOneMarkFromConsole(){ // abstrakt int mark=0; cout << "Note eingeben:"; cin >> mark; setmarkcount( mark, getmarkcount(mark)+1 ); void ExamResult::setMarkCount(int mark, int val) { // nicht abstrakt assert( mark>0 && mark<6 ); // Vorbedingung; Abbruch nicht angemessen marklist[mark-1] = val; // hier fehlt eigentlich wieder fehlertolerante Eingabeschleife // Aufwand: puuuh!! float ExamResult::mean() { // abstrakt int sum (0), cnt(0); for( int mark = 1; mark <= 5; mark++ ) { sum += getmarkcount(mark)*mark; cnt += getmarkcount(mark); return static_cast <float> (sum)/cnt; // Division durch 0 möglich; Fehlerbahndlung nur an Aufrufstelle möglich // Rückgabewert? Möglicherweise negatives Ergebnis! C++ Ausnahmebehandlung 5

6 Konzept der Ausnahmebehandlung in C++ Unterstützt Fehlerbehandlung in mehreren voneinander unabhängig geschriebenen Programmteilen. Trennt Fehlererkennung von Fehlerbehandlung Unterstützt den Fall, dass ein fehlererkennender Programmteil einen anderen Programmteil über einen Fehler informieren muss, weil nur dort der Fehler angemessen behandelt werden kann. Ablauf: 1. Ein Programmteil (try-block) versucht die Erledigung einer Aufgabe erzeugt im Fehlerfall ein Ausnahme-Objekt (exception), das im Fehlerbehandlungsblock ausgewertet werden kann und das eine Fehlermeldung und/oder Daten zum Wiederaufsetzen enthält. Diesen Vorgang bezeichnet man auch als "Auswerfen" einer Ausnahme: if(fehlerfall) throw AusnahmeObjekt; Danach wird zum nächsten passenden Fehlerbehandlungsblock (catch-block) gesprungen (quasi ein spezielles "goto" mit Zusatzinformationen) der zum Typ der ausgeworfenen Ausnahme passt. 2. Ein anderer Programmteil (catch-block) hinter einem try-block behandelt den Fehler gesteuert durch das ausgeworfene Ausnahmeobjekt und erledigt alle notwendigen Aufräumarbeiten (stack unwinding), wenn dabei ein Rücksprung zu aufrufenden Funktionen erforderlich ist. Diesen Vorgang bezeichnet man als "Auffangen" der Ausnahme. 3. Im Unterschied zu Strategie 4 wird das Programm nicht hinter der Fehlererkennungsstelle, sondern hinter der Fehlerbehandlungsstelle, dem catch-block fortgesetzt C++ Ausnahmebehandlung 6

7 Entwicklungsumgebung MS Visual C Nur wenn wenn die Compileroption /EHsc gesetzt ist, generiert der Compiler auch Code für die Ausnahmebehandlung! C++ Ausnahmebehandlung 7

8 int Ausnahme auswerfen und auffangen ohne Wertberücksichtigung void ExamResult::setMarkCount( int mark, int val ) { if( mark<0 mark>5 ) throw 1; marklist[mark-1] = val; int main() { ExamResult mathexam; int item=0; while(true) { // hier folgt die Eingabeschleife (unverändert) try { switch( item) { case 1: mathexam.recordonemarkfromconsole(); break; case 2: mathexam.show(); break; // Fehlererkennung case 3: cout << endl << "Durchschnittsnote: " << mathexam.mean() << endl; break; case 9: return 0; default: cout << "ERROR: nur 1, 2, 3, 9 zulaessig!" << endl << endl; // end try catch ( int ) { cout << "ERROR" << endl; // while(true) // Wenn in diesem try-block Ausnahmen ausgeworfen werden // wird das Programm hier fortgesetzt // und die passende Fehlerbehandler ausgewählt // und Fehlerbehandlung sind nun getrennt! // Dieser catch-block wird ausgewählt, // wenn er zum Typ der ausgeworfenen Ausnahme paßt Der Wert des Ausnahmeobjekts wird hier nicht genutzt // setmarkcount wirft int Ausnahme // falls mark ungültig! 1 Noten erfassen 2 Notenspiegel ausgeben 3 Durchschnittsnote berechnen und ausgeben 9 Programm beenden Bitte waehlen: 1 Note eingeben: 6 ERROR 1 Noten erfassen 2 Notenspiegel ausgeben 3 Durchschnittsnote berechnen und ausgeben 9 Programm beenden Bitte waehlen: C++ Ausnahmebehandlung 8

9 int Ausnahme auswerfen und auffangen mit Wertberücksichtigung void ExamResult::setMarkCount( int mark, int val ) { if( mark<0 mark>5 ) throw 1; // Fehlererkennung marklist[mark-1] = val; int main() { ExamResult mathexam; int item=0; while(true) { // hier folgt die Eingabeschleife (unverändert) try { switch( item) { case 1: mathexam.recordonemarkfromconsole(); break; case 2: mathexam.show(); break; case 3: cout << endl << "Durchschnittsnote: " << mathexam.mean() << endl; break; case 9: return 0; default: cout << "ERROR: nur 1, 2, 3, 9 zulaessig!" << endl << endl; // end try // while(true) catch ( int errno ) { switch(errno) { case 1: cout << "ERROR " << errno // setmarkcount wirft int Ausnahme // falls mark ungültig! Der Wert des Ausnahmeobjekts ist lokale Variable errno in diesem catch-block << ": Falsche Note in ExamResult::setMarkCount!" Der Wert des Ausnahmeobjekts wird hier genutzt 1 Noten erfassen 2 Notenspiegel ausgeben 3 Durchschnittsnote berechnen und ausgeben 9 Programm beenden Bitte waehlen: 1 Note eingeben: 6 ERROR 1: Falsche Note in ExamResult:setMarkCount! C++ Ausnahmebehandlung 9

10 string Ausnahme auswerfen und auffangen void ExamResult::setMarkCount( int mark, int val ) { if(mark<0 mark>5) throw string("error: Falsche Note in ExamResult::setMarkCount!"); marklist[mark-1] = val; int main() { ExamResult mathexam; int item=0; while(true) { // hier folgt die Eingabeschleife (unverändert) try { // wie gehabt... // setmarkcount wirft string Ausnahme // falls mark ungültig! // end try catch ( string str ) { cout << str << endl; // while(true) Der Wert des Ausnahmeobjekts wird hier genutzt 1 Noten erfassen 2 Notenspiegel ausgeben 3 Durchschnittsnote berechnen und ausgeben 9 Programm beenden Bitte waehlen: 1 Note eingeben: 6 ERROR: Falsche Note in ExamResult:setMarkCount! C++ Ausnahmebehandlung 10

11 Userdefiniertes Fehlerobjekt ohne Zusatzinformation Spezielle Fehlerklasse class ExamResultError{ ; // Standard-Konstruktor, Copy-Konstruktor und Destruktor werden automatisch bereitgestellt! // Das Fehlerobjekt hat keine Attribute. Es transportiert daher auch keine Informationen über den Fehler void ExamResult::setMarkCount( int mark, int val ) { if( mark<0 mark>5 ) throw MarkError(); marklist[mark-1] = val; int main() { ExamResult mathexam; int item=0; while(true) { // hier folgt die Eingabeschleife (unverändert) try { // wie gehabt... // end try catch ( ExamResultError ) { cout << "ERROR: Falsche Note in class ExamResult!" // while(true) Nur der Typ der Ausnahme wird hier genutzt zur Auswahl des catch-blocks Der Wert des Ausnahmeobjekts wird hier nicht genutzt Mehr Information gibt das Ausnahmeobjekt hier nicht her C++ Ausnahmebehandlung 11

12 Userdefiniertes Fehlerobjekt mit Zusatzinformation void ExamResult::setMarkCount( int mark, int val ) { if( mark<0 mark>5 ) throw ExamResult( "setmarkcount: Note = ", mark ); marklist[mark-1] = val; class ExamResultError { int value; string message; // Attribute des Fehlerobjekts transportieren Infos zum Fehler zur Fehlerbehandlungsroutine public: ExamResultError( const string& msg, int val=0 ) : message(msg) { value = val; ostream& show( ostream& os ) { os << "ERROR in ExamResult::" << message << value; return os; ; int main() { ExamResult mathexam; int item=0; while(true) { // hier folgt die Eingabeschleife (unverändert) try { // wie gehabt... // end try catch ( ExamResultError exre ) { exre.show(cout); // while(true) 1 Noten erfassen 2 Notenspiegel ausgeben 3 Durchschnittsnote berechnen und ausgeben 9 Programm beenden Bitte waehlen: 1 Note eingeben: 6 ERROR in ExamResult::setMarkCount: Note = C++ Ausnahmebehandlung 12

13 Userdefiniertes Fehlerobjekt mit Zusatzinformation Jetzt kann auch "Division durch Null"-Fehler in mean erkannt und an Aufrufstelle behandelt werden float ExamResult::mean() { int sum (0), cnt(0); for( int mark = 1; mark <= 5; mark++ ) { sum += getmarkcount(mark)*mark; cnt += getmarkcount(mark); if( cnt==0 ) throw ExamResultError( "mean: cnt = ", 0 ); return static_cast <float> (sum)/cnt; //Falls cnt=0 wird diese Anweisung nicht ausgeführt! 1 Noten erfassen 2 Notenspiegel ausgeben 3 Durchschnittsnote berechnen und ausgeben 9 Programm beenden Bitte waehlen: 3 Note eingeben: 6 ERROR in ExamResult::mean: cnt = C++ Ausnahmebehandlung 13

14 C++ Exceptions - Regeln Regeln zum Auswerfen von Ausnahmen Code in try-block oder catch-block kann einen throw-ausdruck enthalten. Der throw-ausdruck hat die Syntax: throw [Ausdruck] (Bei Ausführung wird eine Ausnahme "ausgeworfen". Der Ausdruck ist optional) Nach dem Auswerfen einer Ausnahme wird das Programm hinter dem try-block fortgesetzt und der zum Typ des Ausnahmeobjekts passende Ausnahme-Handler (catch-block) gesucht. Regeln zum Behandeln der Ausnahme Nach dem Auswurf einer Ausnahme wird der "nächste" Handler gesucht, der zum Typ des Ausnahmeobjekts passt. Am "nahsten" sind die catch-blöcke, die dem auswerfenden try-block folgen. Mit dem (temporären) Ausnahmeobjekt wird der Parameter des passenden catch- Blocks initialisiert. Wenn unter den Handlern, die einem try-block folgen, kein passender Handler gefunden wird, wird die Suche im nächsten umschließenden try-block fortgesetzt. Wenn überhaupt kein passender Handler gefunden wurde, wird die Funktion unexpected() aufgerufen. Die Standardversion von unexpected() ruft terminate() auf, sie kann aber durch eine eigene Funktion ersetzt werden C++ Ausnahmebehandlung 14

15 Exception-Spezifikationen in Deklarationen Zweck Ausnahmen, die eine Funktion auswerfen kann, für den Schnittstellen-Anwender bereits in der Schnittstellen-Deklaration bekannt machen. Anwendung void function(); // bel. Funktion kann beliebige Ausnahmen auswerfen. void function() throw(); verspricht, keine Ausnahmen auszuwerfen. void function() throw( RangeError, string ); verspricht, nur die deklarierten Ausnahmen auszuwerfen. Wenn eine Funktion eine Exception wirft, die in der Exception-Spezifikation nicht vorgesehen ist, wird die Funktion void unexpected() aufgerufen, die das Programm beendet. Beispiel class ExamResult { public: float mean() throw(examresulterror); void setmarkcount( int mark, int val ) throw(examresulterror); int getmarkcount( int mark ) throw(examresulterror); ; Hinweis Microsoft C unterstützt die Exception-Spezifikation in Deklarationen nicht C++ Ausnahmebehandlung 15

16 Anwendung der Exception-Hierarchie Viele Klassen und Funktionen der C++ Systembibliothek werfen im Fehlerfall Ausnahmeobjekte vom Typ exception aus. // out_of_range Exception // compile with: /EHsc #include <vector> #include <iostream> using namespace std; void main() { vector<int> v(10,0); try { cout << v.at(11) << endl; Caught: invalid vector<t> subscript string str( "Micro" ); Caught: invalid string position string rstr( "soft" ); str.append( rstr, 5); cout << str << endl; Index des 1. anzuhängenden Zeichens catch ( const exception &e ) { cerr << "Caught: " << e.what( ) << endl; catch(...) { cerr << "Unbehandelter Fehler!" << endl; C++ Ausnahmebehandlung 16

17 Exception-Hierarchie in C++ C++ stellt eine Reihe vordefinierter Exception-Klassen zur Verfügung, die alle von der Oberklasse exception (definiert in <stdexcept>) abgeleitet sind. Alle abgeleiteten Klassen erben von exception der Oberklasse exception namspace std { class exception { public: wirft selbst keine Ausnahmen exception() throw(); Standard-Konstruktor exception( const char* msg) throw(); Copy-Konstruktor exception( const exception& ) throw(); exception& operator=(const exception& rhs) throw(); virtual ~exception() throw(); virtual const char* what() const throw(); private: const char* str; // ; Returns the message msg with which the exception was created. Hier nochmal reinschauen nachdem Sie "geerbt" haben! runtime_error range_error overflow_error underflow_error bad_alloc bad_typeid bad_cast bad_exception C++-Vererbungshierarchie zur Verwendung durch STL logic_error invalid_argument length_error out_of_range domain_error C++ Ausnahmebehandlung 17