Fehlerbehandlung in C++

Diese Lektion behandelt die Techniken zur Erkennung und Behandlung von Fehlern in C++. Fokus liegt auf Ausnahmen (exceptions) und bewährten Vorgehensweisen.

1. Warum Fehlerbehandlung?

Programme können zur Laufzeit auf unerwartete Zustände stoßen. Fehlerbehandlung sorgt dafür, dass Programme kontrolliert reagieren, statt abzustürzen.

Eingabefehler (falsche Dateinamen, ungültige Werte)
Division durch Null
Speicherprobleme
Externe Ressourcen nicht verfügbar (Dateien, Netzwerke)

2. Fehler in C++

Fehler können kategorisiert werden als:

Logische Fehler: Programm läuft, aber liefert falsche Ergebnisse
Laufzeitfehler: z.B. Division durch Null, Nullpointerzugriff
Syntaxfehler: Compile-Zeit Fehler, verhindert Übersetzung

3. Exceptions – Grundidee

C++ verwendet Exceptions zur Behandlung von Laufzeitfehlern.

Mit throw wird eine Ausnahme ausgelöst
Mit try wird Code markiert, der Fehler auslösen kann
Mit catch wird die Ausnahme abgefangen und behandelt

try {
    int a = 10, b = 0;
    if(b == 0) throw "Division durch Null!";
    int c = a / b;
} catch(const char* msg) {
    std::cerr << "Fehler: " << msg << std::endl;
}

4. Exception-Klassen

C++ bietet Standardklassen für Exceptions im Header <stdexcept>:

std::exception – Basisklasse aller Standard-Exceptions
std::runtime_error – allgemeiner Laufzeitfehler
std::logic_error – logische Fehler
std::out_of_range – Index außerhalb gültiger Bereiche

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::out_of_range("Index außerhalb");
    } catch(const std::out_of_range& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    }
}

5. Benutzerdefinierte Exceptions

Eigene Fehlerklassen können von std::exception abgeleitet werden.

class MyError : public std::exception {
    const char* what() const noexcept override {
        return "Mein eigener Fehler!";
    }
};

try {
    throw MyError();
} catch(const MyError& e) {
    std::cerr << e.what() << std::endl;
}

6. Best Practices

Nur Ausnahmen für unerwartete, nicht triviale Fehler verwenden
Ressourcen immer sauber freigeben (RAII-Prinzip)
Smart Pointer helfen, Speicherlecks auch bei Exceptions zu vermeiden
Catch-by-reference: catch(const std::exception& e)
Generell: try/catch so eng wie möglich halten

7. RAII (Resource Acquisition Is Initialization)

Objekte verwalten Ressourcen so, dass beim Verlassen des Gültigkeitsbereichs automatisch aufgeräumt wird.

#include <fstream>
std::ifstream file("data.txt");
if(!file) throw std::runtime_error("Datei nicht gefunden");
// file wird beim Verlassen des Scope automatisch geschlossen

8. Zusammenfassung

Fehlerbehandlung wichtig für stabile Programme
Exceptions mit try, throw, catch
Standard- und benutzerdefinierte Exception-Klassen
RAII und Smart Pointer sichern Ressourcen automatisch
Fehler früh erkennen, korrekt behandeln, Speicherlecks vermeiden