C++ Academy · Lektion

Benutzerdefinierte Exception-Typen

Eigene Exceptions definieren

Benutzerdefinierte Exception-Typen ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum benutzerdefinierte Ausnahmen?

Wenn Sie eigene Ausnahmetypen definieren, können Aufrufer Ihre Fehler gezielt abfangen und domänenspezifische Daten zusammen mit dem Fehler übertragen.

Von std::exception ableiten

Leiten Sie Ihre Ausnahmen von std::exception (oder einer davon abgeleiteten Klasse) ab, damit sie sich in Standard-Handler integrieren und what() bereitstellen.

#include <exception>
#include <string>

class ConfigError : public std::exception {
    std::string msg;
public:
    explicit ConfigError(std::string m) : msg(std::move(m)) {}
    const char* what() const noexcept override { return msg.c_str(); }
};

Auslösen und Abfangen

Ihr Typ verhält sich wie jede andere Ausnahme: Lösen Sie ihn aus und fangen Sie ihn per Referenz ab.

#include <iostream>
#include <exception>
#include <string>

class ConfigError : public std::exception {
    std::string msg;
public:
    explicit ConfigError(std::string m) : msg(std::move(m)) {}
    const char* what() const noexcept override { return msg.c_str(); }
};

int main() {
    try {
        throw ConfigError("missing key");
    } catch (const ConfigError& e) {
        std::cout << e.what() << "\n";
    }
}

Standardbasisklassen wiederverwenden

Oft können Sie von std::runtime_error oder std::logic_error ableiten. Diese speichern bereits eine Nachricht, wodurch weniger wiederholter Code nötig ist.

#include <stdexcept>
#include <string>

class NetworkError : public std::runtime_error {
public:
    explicit NetworkError(const std::string& m) : std::runtime_error(m) {}
};

Zusätzliche Daten übertragen

Benutzerdefinierte Ausnahmen können Felder wie einen Fehlercode oder den fehlerhaften Wert enthalten und Handlern dadurch mehr Kontext liefern.

#include <stdexcept>
#include <string>

class HttpError : public std::runtime_error {
public:
    int status;
    HttpError(int s, const std::string& m)
        : std::runtime_error(m), status(s) {}
};

Über die Basisklasse abfangen

Da Ihr Typ von std::exception abgeleitet ist, kann ein allgemeiner Handler ihn weiterhin über die Basisklassenreferenz abfangen.

#include <iostream>
#include <stdexcept>

class HttpError : public std::runtime_error {
public:
    int status;
    HttpError(int s, const std::string& m) : std::runtime_error(m), status(s) {}
};

int main() {
    try {
        throw HttpError(404, "not found");
    } catch (const std::exception& e) {
        std::cout << e.what() << "\n";
    }
}

Eine Ausnahmehierarchie aufbauen

Gruppieren Sie verwandte Fehler unter einer gemeinsamen Basisklasse, damit Aufrufer eine ganze Fehlerfamilie oder einen einzelnen spezifischen Typ abfangen können.

#include <stdexcept>

struct AppError : std::runtime_error { using std::runtime_error::runtime_error; };
struct DbError  : AppError       { using AppError::AppError; };
struct AuthError: AppError       { using AppError::AppError; };

what() noexcept halten

Überschreiben Sie what() als const noexcept und geben Sie einen stabilen Puffer zurück – die Methode darf niemals eine Ausnahme auslösen oder einen ungültig gewordenen Zeiger zurückgeben.

Per Wert auslösen

Lösen Sie Ausnahmeobjekte per Wert aus (z. B. throw HttpError(500, "x");). Die Laufzeitumgebung verwaltet ihren Speicher während des Stack-Unwinding.

Dokumentieren, welche Ausnahmen ausgelöst werden

Machen Sie die Ausnahmetypen Ihrer API zu einem Teil ihres Vertrags, damit Aufrufer wissen, welche Handler sie schreiben müssen.

Einfach halten

Die meisten Projekte benötigen nur eine kleine Anzahl von Ausnahmetypen. Die Ableitung von std::runtime_error deckt die Mehrheit der Fälle auf saubere Weise ab.

Kurze Überprüfung

Testen Sie Ihr Verständnis benutzerdefinierter Ausnahmen.

Zusammenfassung

Sie haben gelernt, benutzerdefinierte Ausnahmetypen durch Ableitung von std::exception oder std::runtime_error zu definieren, zusätzliche Daten zu übertragen, Hierarchien aufzubauen, what() als noexcept beizubehalten und Ausnahmen per Wert auszulösen. Halten Sie die Anzahl der Typen klein und dokumentieren Sie sie.

Häufig gestellte Fragen

Ist die Lektion „Benutzerdefinierte Exception-Typen“ kostenlos?

Ja — der vollständige Text von „Benutzerdefinierte Exception-Typen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Benutzerdefinierte Exception-Typen“?

Eigene Exceptions definieren Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Benutzerdefinierte Exception-Typen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C++ Academy