C++ Exception Handling meistern: Praktische try, catch, throw Beispiele

Was ist Exception Handling in C++?

Exception Handling ermöglicht C++‑Programmen, sich bei unerwarteten Laufzeitfehlern kontrolliert zu erholen. Tritt ein Fehler auf, springt die Kontrolle zu einem speziellen Handler, der entscheiden kann, wie darauf reagiert wird.

Indem Sie potenziell problematischen Code in einen try‑Block einschließen und ihm ein oder mehrere catch‑Klauseln folgen lassen, geben Sie dem Programm einen klaren Pfad zur Behandlung außergewöhnlicher Situationen.

Wird keine Exception geworfen, läuft der try‑Block normal ab und die Handler werden übersprungen.

In diesem Tutorial lernen Sie:

• Was Exception Handling ist und warum es wichtig ist
• Die Kern‑Schlüsselwörter: throw, catch, try
• Syntax und gängige Muster
• Standard‑Exceptions der C++‑Standardbibliothek
• Wie man benutzerdefinierte Exceptions erstellt und nutzt

Warum Exception Handling?

Exception Handling bietet konkrete Vorteile:

• Trennt Fehlerbehandlungs‑Logik vom regulären Code, was Lesbarkeit und Wartbarkeit verbessert.
• Ermöglicht Funktionen, nur die Exceptions preiszugeben, die sie betreffen; Aufrufer können den Rest behandeln.

Schlüsselwörter der Exception‑Behandlung

Drei Schlüsselwörter bilden das Rückgrat:

• throw – signalisiert einen Fehlerzustand, indem ein Exception‑Objekt erzeugt wird.
• catch – fängt eine Exception ab und stellt Code bereit, um darauf zu reagieren.
• try – markiert den Codebereich, der Exceptions werfen kann.

Code innerhalb des try‑Blocks wird als geschützter Code bezeichnet; wirft er eine Exception, wird der zugehörige catch‑Block ausgeführt.

Syntax

try {
    // geschützter Code
} catch (Exception_Typ exception1) {
    // exception1 behandeln
} catch (Exception_Typ exception2) {
    // exception2 behandeln
} // ... weitere catch‑Blöcke

• Ein einzelner try kann von mehreren catch‑Klauseln gefolgt werden.
• Der Typ in jeder catch‑Klausel spezifiziert die abzufangende Exception.
• Innerhalb eines catch kann die gefangene Exception über den gewählten Bezeichner referenziert werden.

Beispiel 1: Zugriff auf Vector‑Element außerhalb des Bereichs

#include <iostream>
#include <vector>
using namespace std;
int main() {
    vector<int> vec;
    vec.push_back(0);
    vec.push_back(1);
    try {
        vec.at(2); // out of range
    } catch (exception& ex) {
        cout << "Exception aufgetreten!" << endl;
    }
    return 0;
}

Ausgabe:

Screenshot des Codes:

Code‑Analyse:

1. iostream und vector für I/O und Container einbinden.
2. std‑Namespace nutzen, um vollqualifizierte Namen zu vermeiden.
3. vector<int> instanziieren und befüllen.
4. Versuch, ein Element außerhalb der Grenzen im try‑Block zuzugreifen.
5. Standard‑std::exception abfangen und Meldung ausgeben.
6. Aus main zurückkehren.

Beispiel 2: Division durch Null behandeln

#include <iostream>
using namespace std;
double zeroDivision(int x, int y) {
    if (y == 0) {
        throw "Division durch Null!";
    }
    return static_cast<double>(x) / y;
}
int main() {
    int a = 11, b = 0;
    double c = 0;
    try {
        c = zeroDivision(a, b);
        cout << c << endl;
    } catch (const char* message) {
        cerr << message << endl;
    }
    return 0;
}

Ausgabe:

Screenshot des Codes:

Code‑Analyse:

1. zeroDivision definieren, das einen C‑String wirft, wenn durch Null geteilt wird.
2. Funktion im try‑Block aufrufen und Ergebnis ausgeben.
3. String‑Exception abfangen und Fehlermeldung ausgeben.

C++ Standard‑Exceptions

Die Standardbibliothek deklariert in <exception> eine reiche Exception‑Hierarchie. Hier die häufigsten:

Exception	Beschreibung
std::exception	Basisklasse für alle Standard‑Exceptions.
std::bad_alloc	Wird von new bei Allokationsfehler geworfen.
std::bad_cast	Wird von dynamic_cast bei fehlgeschlagenem Cast geworfen.
std::bad_exception	Signalisiert eine unerwartete Exception.
std::bad_typeid	Wird von typeid auf einen null‑glvalue eines polymorphen Typs geworfen.
std::logic_error	Fehler, die der Programmierer erkennen können sollte.
std::domain_error	Ungültiger Definitionsbereich für mathematische Funktion.
std::invalid_argument	Funktion erhielt ungültiges Argument.
std::length_error	Versuch, einen zu großen String zu erzeugen.
std::out_of_range	Wird von vector::at bei Index außerhalb geworfen.
std::runtime_error	Laufzeitfehler, die keine andere Kategorie treffen.
std::overflow_error	Mathematischer Überlauf aufgetreten.
std::range_error	Wert außerhalb des gültigen Bereichs für die Operation.
std::underflow_error	Mathematischer Unterlauf aufgetreten.

Benutzerdefinierte Exceptions

Die Basisklasse std::exception kann erweitert werden, um domänenspezifische Fehlertypen zu schaffen. Das Überschreiben von what() liefert eine beschreibende Nachricht.

Beispiel: Eigene Exception

#include <iostream>
#include <exception>
using namespace std;
class NewException : public exception {
public:
    const char* what() const noexcept override {
        return "newException aufgetreten";
    }
} newex;
int main() {
    try {
        throw newex;
    } catch (exception& ex) {
        cout << ex.what() << '\n';
    }
    return 0;
}

Ausgabe:

Screenshot des Codes:

Code‑Analyse:

1. NewException von std::exception ableiten und what() überschreiben.
2. Objekt newex instanziieren zum Werfen.
3. newex im try‑Block werfen.
4. Per Referenz auf std::exception abfangen und Nachricht via what() ausgeben.

Merksätze

• Exception Handling ist essenziell für robuste C++‑Anwendungen, die Laufzeitfehler abfangen müssen.
• Nutzen Sie try zum Schutz, catch zur Reaktion und throw zum Signalisieren.
• Profitieren Sie vom reichen Satz an Standard‑Exceptions und erweitern Sie std::exception, wenn eigene Fehlertypen nötig sind.
• Halten Sie Fehlerbehandlungs‑Logik getrennt von Geschäftslogik für sauberen, wartbaren Code.