Katastrophenschutz mit try und catch

Es ist unmöglich, idiotensichere Programme zu schreiben, da Idioten so erfinderisch sind.

Tatsächlich ist es nicht leicht, gegen das Gesetz von Murphy (»If anything can go wrong it will.«) anzukämpfen. Der Programmierer muss nicht nur den Algorithmus im Blick behalten, sondern alle Fehleingaben, Systemfehler und Unverträglichkeiten vorhersehen und ausschalten.

try und catch

[Fehlerfangen]

try
{
    int divisor=0;
    int dividend=1;
    int quotient = dividend/divisor; // hier knallt es!
}
catch (...)
{

    cout << "Problem erkannt..." << endl;
}

Die Division durch 0 im Beispiel würde normalerweise zu einem Programmabsturz führen. Man nennt einen solchen Fehler eine >>Exception<< oder auf Deutsch >>Ausnahme<<. Tritt eine solche Ausnahme in einem try-Block auf, dann wird die Verarbeitung in dem behandelnden catch-Block fortgesetzt. [1]

Vorteile

Drei Punkte

Wirkungskreis

Eigene Ausnahmen erzeugen

throw

[Ausnahme mit throw generieren]

#include <iostream>
using namespace std;

void Tuwas(int Problem)
{
    if (Problem>0)
    {
        throw 0;
    }
}

int main()
{
    try
    {
        Tuwas(1);
    }
    catch(...)
    {
        cout << "Da gab es ein Problem!" << endl;
    }
}

Der Befehl throw in der Funktion Tuwas() löst eine Ausnahme aus, wenn der Parameter Problem größer als 0 ist. Die Verarbeitung wird sofort im catch-Block fortgesetzt.

Parameterübergabe

[throw übermittelt eine Fehlernummer]

#include <iostream>
using namespace std;

void Tuwas(int Problem)
{
    if (Problem>0)
    {
        throw 5;
    }
}

int main()
{
    try
    {
        Tuwas(1);
    }
    catch(int a)
    {
        cout << "Ausnahme: " << a << endl;
    }
}

Wenn der catch-Block int als Parameter hat, bearbeitet er nur Ausnahmen, die durch einen throw-Befehl mit einer Zahl als Argument ausgelöst wurden. Um andere Parameter zu bearbeiten, wird einfach ein weiterer catch-Block mit einem anderen Parametertyp angehängt. Um alle übrigen Ausnahmen zu behandeln, kann der allgemeine catch-Befehl mit den drei Punkten als Parameter ganz zum Schluss auch noch angehängt werden. Ganz ähnlich wie bei überladenen Funktionen werden die passenden catch-Blöcke nach ihren Parametern ausgewählt. Allerdings hat ein catch immer nur einen Parameter. Eine automatische Typanpassung wie bei Funktionen wird hier nicht durchgeführt. Wenn Sie also beispielsweise throw mit dem Argument 1.2 verwenden, muss der passende catch als Parameter double und nicht float haben, weil Fließkommakonstanten vom Compiler standardmäßig als double behandelt werden. Das folgende Beispiel zeigt mehrere catch-Blöcke für verschiedene Typen.

[Mehrere catch-Blöcke (throwtyp.cpp)]

// Programm zur Demonstration verschiedener catch-Bloecke
#include <iostream>
using namespace std;

// Tuwas wird unterschiedliche Typen werfen, je nach dem
// Wert des Parameters Problem.
void Tuwas(int Problem)
{
    switch (Problem)
    {
    case 0: throw 5; break;                  // wirft int
    case 1: throw (char *)"test.dat"; break; // wirft char *
    case 2: throw 2.1; break;                // wirft double
    case 3: throw 'c'; break;                // wirft char
    }
}

// Testprogramm
int main()
{
    // Problem-Nummer eingeben
    int Auswahl;
    cout << "Zahl zwischen 0 und 3 eingeben:" << endl;
    cin >> Auswahl;
    // Der try-Block fängt die Exception in Tuwas
    try
    {
        Tuwas(Auswahl);
    }
    catch(int i) // Behandler für int
    {
        cout << "Integer " << i << endl;
    }
    catch(char *s) // Behandler für char*
    {
        cout << "Zeichenkette " << s << endl;
    }
    catch(double f) // Behandler für double
    {
        cout << "Fließkomma " << f << endl;
    }
    catch(...) // fängt alle anderen Exception-Typen
    {
        cout << "Allgemeinfall" << endl;
    }
}

Wenn Sie das Programm starten, können Sie durch die Zahlen 0 bis 3 auswählen, welche Ausnahme ausgelöst wird. Bei 1 wird eine Zeichenkette >>geworfen<<, die dann im catch-Block als Parameter s auch weiterverarbeitet werden kann. Bei 3 wird ein char >>geworfen<<, für den kein catch-Block vorgesehen ist. Also wird diese Ausnahme vom allgemeinen catch-Block gefangen.

Erstellen von Fehlerklassen

[Eigener Fehlertyp]

#include <iostream>
using namespace std;

class KeineDatenMehr
{
};

void Tuwas(int Problem)
{
    ...
        throw KeineDatenMehr();
    ...
}

int main()
{
    try
    {
        Tuwas(0);
    }
    catch(KeineDatenMehr& )
    {
        cout << "Keine Daten mehr vorhanden" << endl;
    }
}

Fehleridentifizierung

Fehlerklasse erweitern

[Fehlerklasse wird aktiv]

#include <iostream>
using namespace std;

class KeineDatenMehr
{
public:
    KeineDatenMehr(int a) { nr = a; }
    void MeldeFehler() { cout << nr << endl; }
private:
    int nr;
};

void Tuwas(int Problem)
{
    if (Problem==0)
    {
        throw KeineDatenMehr(8);
    }
}

int main()
{
    try
    {
        Tuwas(0);
    }
    catch(KeineDatenMehr& fehler)
    {
        fehler.MeldeFehler();
    }
}

Polymorphie

[Polymorphe Fehlerklasse (tryclass.cpp)]

#include <iostream>
using namespace std;

class meaCulpa // Basisklasse aller meiner Fehler
{
public:
    virtual void MeldeFehler() = 0;
};

class KeineDatenMehr : public meaCulpa
{
public:
    KeineDatenMehr(int a) { nr = a; }
    void MeldeFehler() { cout << nr << endl; }
private:
    int nr;
};

class QuelleFehlt : public meaCulpa
{
public:
    QuelleFehlt() {}
    void MeldeFehler() { cout << "Quelle fehlt" << endl; }
};

void Tuwas(int Problem) throw (KeineDatenMehr, QuelleFehlt)
{
    if (Problem==0)
    {
        throw KeineDatenMehr(8);
    }
    if (Problem==1)
    {
        throw QuelleFehlt();
    }
}

int main()
{
    try
    {
        Tuwas(0);
    }
    catch(meaCulpa& fehler)
    {
        fehler.MeldeFehler();
    }
}

Wie immer bei der Polymorphie wird ein Zeiger auf das übergebene Objekt verwendet, um die virtuelle Funktion aufzurufen. Das Objekt kennt sich selbst und ruft über die eigene VTable die zugehörige Funktion MeldeFehler() auf. Einen ähnlichen Ansatz bieten die Standardbibliotheken. Sie verwenden Fehlerklassen, die auf der Klasse exception basieren. Wie Sie Ihre Fehlerklasse von exception ableiten können, wird auf den nächsten Seiten beschrieben.

throw-Deklaration

Die Ausnahmen der Standardbibliotheken

Die Klasse exception

Eigene Ableitung von exception

class exception
{
public:
    exception() throw();
    exception(const exception&) throw();
    exception& operator=(const exception&) throw();
    virtual ~exception() throw();
    virtual const char * what() const throw();
};

Um eine solche Ableitung zu definieren, muss zunächst die Header-Datei exception eingebunden werden, da hier die Klasse exception definiert wird. Das folgende Beispiel zeigt die Klasse meaCulpa, die nun von exception abgeleitet wird. Als spezielle Ausnahmen werden wieder KeineDatenMehr und QuelleFehlt davon abgeleitet.

[Fehlerklassen von exception ableiten (exception.cpp)]

#include <iostream>
#include <exception>
#include <string>
#include <sstream>
using namespace std;

// Meine eigene Basisklasse, abgeleitet von exception
class meaCulpa : public exception
{
public:
    meaCulpa(string s) {this->s = s;}
    virtual ~meaCulpa() throw() {}
    virtual const char * what() const throw()
        {return s.c_str();}
private:
    string s;
};

// Besonderer Fehler, wenn keine Daten mehr vorliegen
class KeineDatenMehr : public meaCulpa
{
public:
    KeineDatenMehr(int a) : meaCulpa(" ") {nr = a;}
    virtual ~KeineDatenMehr() throw() {}
    virtual const char * what() const throw();
private:
    int nr;
    string s;
};

// what() wird für eigene Fehlermeldung überschrieben
const char * KeineDatenMehr::what() const throw()
{
  ostringstream getNr;
  getNr << "Keine Daten mehr. Fehlernr.: " << nr;
  return getNr.str().c_str();
}

// Eine weitere Fehlerart wird von meaCulpa abgeleitet.
class QuelleFehlt : public meaCulpa
{
public:
    QuelleFehlt() : meaCulpa("Quelle fehlt") {}
};

// Tuwas simuliert die beiden Fehlerarten in Abhängigkeit vom
// Parameter
void Tuwas(int Problem) throw (KeineDatenMehr, QuelleFehlt)
{
    if (Problem==0)
    {
        throw KeineDatenMehr(8);
    }
    if (Problem==1)
    {
        throw QuelleFehlt();
    }
}

int main()
{
    // Problem-Nummer eingeben
    int Auswahl;
    cout << "Zahl zwischen 0 und 3 eingeben:" << endl;
    cin >> Auswahl;
    // Der try-Block fängt die Exception in Tuwas
    try
    {
        Tuwas(Auswahl);
    }
    // Fängt nur die eigenen Fehler
    catch(meaCulpa& fehler)
    {
        cout << fehler.what() << endl;
    }
}

Die Fehlerklasse KeineDatenMehr erwartet im Konstruktor eine ganze Zahl. Der Konstruktor ruft für meaCulpa den Konstruktor mit dem String als Parameter auf. Die Funktion what() wird von KeineDatenMehr neu implementiert. Die Fehlernummer wird, begleitet von ein wenig Text, in eine Zeichenkette konvertiert und als C-String zurückgegeben. Die Fehlerklasse QuelleFehlt gibt einfach ihre Meldung an den Konstruktor von meaCulpa durch und braucht darum what() nicht neu zu implementieren.

Übersicht über die Standardfehlerklassen

runtime_error

Laufzeitfehler. Davon abgeleitet sind folgende Fehlerklassen:

ios_base::failure
Fehlerklasse der Stream-Klassen. Sie ist nicht bei allen Compilern verfügbar.
range_error
Bereichsüberschreitung. Wird durch die at()-Funktion ausgelöst.
overflow_error
Überlauf bei Berechnungen.
underflow_error
Unterlauf bei Berechnungen.

logic_error

Logische Fehler. Davon abgeleitet sind folgende Fehlerklassen:

domain_error

Bereichsfehler.

invalid_argument

Unzulässiges Argument.

length_error

Beim Anlegen wurde die maximal mögliche Größe überschritten.

out_of_range

Zugriff mit unzulässigem Index.

bad_alloc

Entsteht, wenn new keinen Speicher anfordern kann.

bad_cast

Im Zusammenhang mit dynamic_cast.

bad_exception

Wenn die Ausnahmebehandlung selbst Probleme bekommt.

bad_typeid

Im Zusammenhang mit typeid.

#include <stdexcept>

int main()
{
  try
  {
    throw range_error("Oha, ist das eng hier!");
  }
  catch(range_error& e)
  {
     cout << e.what() << endl;
  }
}

Ausnahmen der Standardklasse fstream

fstream f;
try
{
    f.exceptions(ios::failbit|ios::badbit);
    f.open("test.dat", ios::in);
    f << "Dieser Text geht in die Datei" << endl;
    f.close();
}
catch(ios::failure&)
{
    if (f.fail()) cout << "fail" << endl;
    if (f.bad())  cout << "bad" << endl;
}

[1]

Bei vielen Versionen des GNU-Compilers (auf jeden Fall bei gcc-2.9.2 und bei gcc-2.95.3, vermutlich auch bei neueren) werden die Divisionen durch 0 und die Fließkomma-Ausnahmen nicht vom generellen catch(...) abgefangen.