Version [22768]
Dies ist eine alte Version von ObjProg03Exceptions erstellt von RonnyGertler am 2013-03-28 23:53:03.
Objektorientierte Programmierung - Kapitel 3 - Exceptions
Inhalte von Dr. E. Nadobnyh
3.1. Traditionelle Fehlerbehandlung
Mögliche Fehlerursachen
1) Division durch Null,
2) zu große oder zu kleine Werte für einen Datentyp,
3) kein dynamischer Speicher mehr verfügbar,
4) Fehler beim Dateizugriff, z.B. Datei nicht vorhanden,
5) ungültige Adresse im Hauptspeicher,
6) fehlerhafte Eingaben durch den Benutzer,
7) Bereichsüberschreitung eines Arrays.
Fehlersituation
Eine Fehlersituation ist ein Verstoß gegen die Spezifikation der Operation. Wenn die Aufgabe der Operation nicht erfüllt ist, ist es meist sinnlos, weitere Anweisungen auszuführen.
Wegen der aufgetretenen Fehlersituation muss die normale Ausführungsreihenfolge unterbrochen werden, um die Fehlersituation zu behandeln.
Beispiel:
if(b==0)
{ //Die Fehlersituation ist ermittelt.
//Die normale Ausführungsreihenfolge muss
//unterbrochen werden.
//Ohne Behandlung tritt der Fehler auf.
}
c = a / b ;
{ //Die Fehlersituation ist ermittelt.
//Die normale Ausführungsreihenfolge muss
//unterbrochen werden.
//Ohne Behandlung tritt der Fehler auf.
}
c = a / b ;
Erkennung und Behandlung von Fehler
1) Der Autor einer Bibliothek kann Fehlersituation erkennen, aber er weiß nicht, wie er sie behandeln soll.
Die Umgebung der Fehlersituation ist eine Stelle im Programm, wo die Fehlersituation entsteht.
2) Der Anwender einer Bibliothek weiß, wie er die Fehlersituation behandeln kann, hat aber keine Möglichkeit sie
zu entdecken.
Die Aufrufumgebung ist eine Stelle im Programm, wo die Fehlersituation behandelt werden kann.
Begriffsdiskussion: Fehlersituationsbehandlung und Fehlerbehandlung
Traditionelle Fehlerbehandlung. Fehlernummer
1) Meldungsausgabe und Programmabbruch, z.B. exit(-2);
2) Übergabe der Fehlernummer an den Aufrufer.
Die Nummer gibt Auskunft über Erfolg oder Misserfolg der Funktionsausführung und kann
- als Parameter,
- als Rückgabewert oder
- mittels globaler Variable
zurückgeliefert werden.
3) Fehlerbehebung, z.B. durch Wiederholung der Eingabe
Demo 1. Fehlernummer
Traditionelle Behandlung. Nachteile
1) Jeder Programmierer entwickelt eigene Regeln für den Umgang mit Fehlersituationen.
Ein Beispiel ist die C-Funktion getchar(), die ein Zeichen liest und zurückliefert. Damit neben jedem beliebigen Zeichen auch ein Fehlerwert zurückgeliefert werden kann, ist der Typ des Rückgabewertes nicht char, sondern int.
2) Nach jedem Aufruf müssen die Fehlerabfragen durchgeführt werden. Dadurch wird das Programm beträchtlich aufgeblasen.
3.2. Grundbegriffe
Exception-Konzept
Eine Exception (Ausnahme) ist eine Kontrollstruktur, welche den Übergang (Sprung) von der Umgebung der Fehlersituation zur Aufrufumgebung erfüllt.
Vorteile:
1) Konzept beruht auf der Trennung des normalen Programmablaufs und der Behandlung von Fehlersituationen.
2) Fehlersituationen werden in der Aufrufumgebung behandelt. Die Fehlersituationen können zentral behandelt werden.
3) Das Programmverhalten wird überschaubar und sicherer.
Anmerkung: Durch eine Exception kann auch eine Fehlersituation bezeichnet werden.
Schlüsselwörter try, catch, throw
Die Ausnahmebehandlung lässt sich wie folgt skizzieren:
1) Eine Funktion versucht (try) die Erledigung einer Aufgabe.
2) Wenn diese Funktion eine Fehlersituation feststellt, die sie nicht beheben kann, wird ein Ausnahmeobjekt (Exception-Objekt, Fehlerobjekt) ausgeworfen (throw) bzw. wird eine Ausnahme (Exception) ausgelöst.
3) Dieses Ausnahmeobjekt wird von einer Ausnahmebehandlungsroutine (Exception-Handler) aufgefangen (catch), die die Fehlersituation bearbeitet.
Rückzugsvarianten
Auslösen und Auffangen von Exceptions
Die throw- Anweisung wird in folgenden Schritten ausgeführt:
1) Fehlerobjekt auswerfen
Vom Parameter der throw- Anweisung wird eine Kopie gemacht und im Heap gespeichert.
2) Stack- Abwicklung
Die Veränderungen des Stacks, die seit dem Eintritt in den try-Block stattgefunden haben, werden rückgängig gemacht. Für alle zerstörten Objekte werden Destruktoren aufgerufen.
Vorsicht: throw ist kein goto.
3) Rückzug aus einer Fehlersituation
Ein passender catch-Block wird gefunden und ausgeführt. Das Fehlerobjekt wird als Argument übergeben.
4) Fehlerobjekt löschen
Beim Verlassen des catch- Blocks wird das Fehlerobjekt im Heap gelöscht.
5) Fortsetzung des Programms
⇒ Demo 2. Stack-Abwicklung
Registrierung von Exceptions
Jede Exception wird von einem Handler übernommen, wenn sie vorher in einem try-Block registriert wird.
Direkt bei Eintritt in ihren Handler wird eine Exception als behandelt betrachtet.
Beispiel:
Dieses Programm erzeugt keine Endlosschleife:
void f()
{ try { throw ( 5 );}
catch(int ) { throw ( 6 ); }
}
{ try { throw ( 5 );}
catch(int ) { throw ( 6 ); }
}
3.3. Details
Unterscheidung von Exceptions
Man kann unterschiedliche Fehlersituationen durch unterschiedliche Werte des Fehlerobjektes darstellen.
Beispiel
try
{ ...; if(dies) throw(7);
...; if(jenes) throw(12);
...; if(sonstwas) throw(25);
}
catch(int i)
{ switch(i)
{ case 7: ...; break; //dies
case 12: ...; break; //jenes
case 25: ...; break; //sonstwas
}
}
{ ...; if(dies) throw(7);
...; if(jenes) throw(12);
...; if(sonstwas) throw(25);
}
catch(int i)
{ switch(i)
{ case 7: ...; break; //dies
case 12: ...; break; //jenes
case 25: ...; break; //sonstwas
}
}
Fehlerklassen
Normaleweise werden für verschiedene Fehler eigene Fehlerklassen definiert. Ein Objekt von Fehlerklasse kann genauere Informationen über die Fehlerursache enthalten.
Beispiel
class Error
{ //Infos über Fehlerursache
};
void f1()
{
if( ?? )
{ Error e1;
//Infos über Fehlerursache in e1 speichern
throw (e1);
}
}
{ //Infos über Fehlerursache
};
void f1()
{
if( ?? )
{ Error e1;
//Infos über Fehlerursache in e1 speichern
throw (e1);
}
}
Handler-Suche
1) Jedem try-Block können mehrere catch- Blöcke (Exception-Handlers) zugeordnet werden.
2) Beim Rückzug aus Fehlersituation wird ein passender Handler gesucht, und zwar sequentiell, beginnend mit dem ersten catch-Block.
3) Es wird der erste Handler ausgeführt, dem das ausgeworfene Fehlerobjekt wie bei einem gewöhnlichen Aufruf übergeben werden kann (exception matching).
Vorsicht: throw ist kein Aufruf.
Genereller Exception-Handler
Als letzter catch- Block kann ein so genannter genereller Exception-Handler definiert werden.
Er übernimmt alle ausgelösten Exceptions, welche von keinem vorherigen Block übernommen werden.
catch(…)
{ //Handler für jede Art von Exceptoin
//drei Punkte statt Typ
}
{ //Handler für jede Art von Exceptoin
//drei Punkte statt Typ
}
Kann im Programm kein Handler gefunden werden, so wird das Programm beendet.
⇒ Demo 3. Handler-Suche
⇒ Demo 4. Erfolglose Handler-Suche
Anordnung von try-Blöcken
In einem Programm können mehrere try-Blöcke mit entsprechenden Exception-Handlern eingesetzt werden. Die Blöcke können sequentiell oder verschachtelt angeordnet werden.
Handler-Suche in verschachtelten Blöcken
1) Einige Exceptions können durch die Handler eines inneren try-Blocks separat behandelt werden.
2) Alle übrigen Exceptions suchen nach dem passenden Handler des äußeren try-Blocks.
Wiederauswerfen von Exception
Eine im inneren try-Block ausgelöste Exception kann an den umgebenen try- Block weitergereicht werden.
Die aktuell bearbeitete Exception wird nochmals ausgeworfen, um vom Handler des umgebenden Blocks
weiter bearbeitet zu werden.
Exception- Spezifikation
Die Exceptions, die von einer Funktion ausgelöst werden kann, gehören zu den Eigenschaften einer Funktion. Sie müssen dem Anwender bekannt sein, damit geeignete Reaktionen programmiert werden können.
An die Funktions-Deklaration (Prototyp) wird einer so genannten Exception- Spezifikation angehängt.
Deklaration:
float pf(float y, float x) throw (DiviNull, Unterlauf);
Definition:
float pf(float y, float x) throw (DiviNull, Unterlauf){...}
Ist die Exception-Liste leer, so wird keine Exception zugelassen.
Deklaration:
float pf(float y, float x) throw ( );
Definition:
float pf(float y, float x) throw ( ){...}
Ist keine Exception- Spezifikation angegeben, so sind alle Exceptions zulässig.
Standard-Fehlerklassen
In C++ wird eine Reihe von Standard-Fehlerklassen definiert.
Einige Klassen:
| Klassenname | Geworfen von der Methode | Bedeutung |
| bad_alloc | new | Speicherzuweisungsfehler |
| bad_cast | dynamic_cast | Typumwandlungsfehler |
| bad_typeid | typeid | Falscher Objekttyp |
| out_of_range | at() | Bereichsüberschreitung in Funktionen der C++ Standard-Bibliothek |
⇒ Demo 5. Fehlerklasse bad_alloc
CategoryObjProg
