C++-Bibliothek für Ausnahmebehandlung <stdexcept>
<stdexcept>Ist eine Header-Datei in der C++-Standardbibliothek, die eine Reihe von Standard-Ausnahmeklassen für die Behandlung von Fehlerbedingungen während der Programmlaufzeit definiert.
Ausnahmen sind Fehler, die während der Programmlaufzeit auftreten; sie können abgefangen und behandelt werden, um einen abnormalen Programmabbruch zu verhindern.<stdexcept>Die Header-Datei definiert eine Reihe von Klassen, die abgeleitet sind vonstd::exceptionAbgeleitete Ausnahmeklassen, die eine Standardmethode zum Melden und Behandeln von Fehlern bereitstellen.
Syntax
Um<stdexcept>Für die beteiligten Ausnahmeklassen müssen Sie zunächst diese Header-Datei einbinden:
#include <stdexcept>
Dann können Sie diese Ausnahmeklassen verwenden, um Ausnahmen auszulösen und abzufangen. Zum Beispiel:
throw std::runtime_error("An error occurred");
Exception-Klasse
<stdexcept>Die Header-Datei definiert die folgenden Ausnahmeklassen:
std::exception: Die Basisklasse aller Standard-Ausnahmeklassen.std::bad_exception: Wird ausgelöst, wenn während der Ausnahmebehandlung ein Fehler auftritt.std::bad_alloc: Wird ausgelöst, wenn die Speicherzuweisung fehlschlägt.std::bad_cast: Wird ausgelöst, wenn die Typkonvertierung fehlschlägt.std::bad_typeid: wanntypeidWird ausgelöst, wenn eine Operation fehlschlägt.std::logic_error: Wird ausgelöst, wenn ein Logikfehler auftritt, z. B. ein ungültiger Eingabeparameter.std::domain_error: Wird ausgelöst, wenn ein Argument eines Funktionsaufrufs außerhalb des gültigen Bereichs liegt.std::invalid_argument: Wird ausgelöst, wenn ein Argument eines Funktionsaufrufs ungültig ist.std::length_error: Wird ausgelöst, wenn eine Container-Operation aufgrund von Längenbeschränkungen fehlschlägt.std::out_of_range: Wird ausgelöst, wenn in einem Container auf einen unzulässigen Index zugegriffen wird.std::overflow_error: Wird ausgelöst, wenn arithmetische Operationen einen Überlauf verursachen.std::range_error: Wird ausgelöst, wenn ein Rückgabewert einer Funktion außerhalb des erwarteten Bereichs liegt.std::underflow_error: Wird ausgelöst, wenn arithmetische Operationen einen Unterlauf verursachen.
Beispiel
Nachfolgend ein Verwendungsbeispiel für<stdexcept>Ein einfaches Beispiel, das zeigt, wie Ausnahmen ausgelöst und abgefangen werden:
Beispiel
#include <stdexcept>
void riskyFunction(int x) {
if (x < 0) {
throw std::invalid_argument("Negativer Wert nicht erlaubt");
}
std::cout << "Verarbeitung " << x << std::endl;
}
int main() {
try {
riskyFunction(-1);
} catch (const std::invalid_argument& e) {
std::cerr << "Ausnahme abgefangen: " << e.what() << std::endl;
}
return 0;
}
Ausgabe:
Caught an exception: Negative value not allowed
In diesem Beispiel,riskyFunctionDie Funktion prüft, ob der übergebene Parameter negativ ist; wenn ja, wirft sie einestd::invalid_argumentAusnahme. InmainIn der Funktion verwenden wirtry-catcheinen Block, um diese Ausnahme abzufangen und zu behandeln.
Standard-Ausnahmeklassen
std::exception
std::exception ist die Basisklasse für alle Standard-Ausnahmeklassen. Sie bietet eine virtuelle Funktion what(), die eine Zeichenkette zurückgibt, die die Ausnahme beschreibt.
Beispiel
#include <exception>
int main() {
try {
throw std::exception();
} catch (const std::exception& e) {
std::cout << "Caught exception: " << e.what() << std::endl;
}
return 0;
}
std::logic_error
std::logic_error ist von std::exception abgeleitet und repräsentiert Programmlogikfehler. Es ist eine abstrakte Basisklasse, die normalerweise durch abgeleitete Klassen konkretisiert wird.
Beispiel
#include <stdexcept>
int main() {
try {
throw std::logic_error("Logikfehler aufgetreten");
} catch (const std::logic_error& e) {
std::cout << "Logikfehler abgefangen: " << e.what() << std::endl;
}
return 0;
}
std::invalid_argument
std::invalid_argument ist von std::logic_error abgeleitet und zeigt an, dass ein ungültiges Argument übergeben wurde.
Beispiel
#include <stdexcept>
int main() {
try {
throw std::invalid_argument("Ungültiges Argument übergeben");
} catch (const std::invalid_argument& e) {
std::cout << "Ungültiges Argument abgefangen: " << e.what() << std::endl;
}
return 0;
}
std::domain_error
std::domain_error ist von std::logic_error abgeleitet und zeigt an, dass ein Argument außerhalb des gültigen Definitionsbereichs liegt.
Beispiel
#include <stdexcept>
int main() {
try {
throw std::domain_error("Domänenfehler aufgetreten");
} catch (const std::domain_error& e) {
std::cout << "Domänenfehler abgefangen: " << e.what() << std::endl;
}
return 0;
}
std::length_error
std::length_error ist von std::logic_error abgeleitet und repräsentiert einen Längenfehler, z. B. das Überschreiten der maximalen Längengrenze bei Container-Operationen.
Beispiel
#include <stdexcept>
int main() {
try {
throw std::length_error("Längenfehler aufgetreten");
} catch (const std::length_error& e) {
std::cout << "Längenfehler abgefangen: " << e.what() << std::endl;
}
return 0;
}
std::out_of_range
std::out_of_range leitet sich von std::logic_error ab und zeigt an, dass ein Zugriff außerhalb des gültigen Bereichs liegt.
Beispiel
#include <stdexcept>
int main() {
try {
throw std::out_of_range("Fehler außerhalb des gültigen Bereichs aufgetreten");
} catch (const std::out_of_range& e) {
std::cout << "Fehler außerhalb des gültigen Bereichs abgefangen: " << e.what() << std::endl;
}
return 0;
}
std::runtime_error
std::runtime_error leitet sich von std::exception ab und repräsentiert Laufzeitfehler von Programmen. Es ist eine abstrakte Basisklasse, die üblicherweise durch abgeleitete Klassen konkretisiert wird.
Beispiel
#include <stdexcept>
int main() {
try {
throw std::runtime_error("Laufzeitfehler aufgetreten");
} catch (const std::runtime_error& e) {
std::cout << "Laufzeitfehler abgefangen: " << e.what() << std::endl;
}
return 0;
}
std::range_error
std::range_error leitet sich von std::runtime_error ab und zeigt an, dass ein Berechnungsergebnis den darstellbaren Bereich überschreitet.
Beispiel
#include <stdexcept>
int main() {
try {
throw std::range_error("Bereichsfehler aufgetreten");
} catch (const std::range_error& e) {
std::cout << "Bereichsfehler abgefangen: " << e.what() << std::endl;
}
return 0;
}
std::overflow_error
std::overflow_error leitet sich von std::runtime_error ab und zeigt einen arithmetischen Überlauffehler an.
Beispiel
#include <stdexcept>
int main() {
try {
throw std::overflow_error("Überlauffehler aufgetreten");
} catch (const std::overflow_error& e) {
std::cout << "Überlauffehler abgefangen: " << e.what() << std::endl;
}
return 0;
}
std::underflow_error
std::underflow_error leitet sich von std::runtime_error ab und zeigt einen arithmetischen Unterlauffehler an.
Beispiel
#include <stdexcept>
int main() {
try {
throw std::underflow_error("Unterlauffehler aufgetreten");
} catch (const std::underflow_error& e) {
std::cout << "Unterlauffehler abgefangen: " << e.what() << std::endl;
}
return 0;
}
Benutzerdefinierte Ausnahmeklassen verwenden
Neben den Standard-Ausnahmeklassen können wir auch eigene Ausnahmeklassen definieren, die von Standard-Ausnahmeklassen erben.
Beispiel
#include <stdexcept>
class MyException : public std::runtime_error {
public:
MyException(const std::string& message) : std::runtime_error(message) {}
};
int main() {
try {
throw MyException("Meine benutzerdefinierte Ausnahme ist aufgetreten");
} catch (const MyException& e) {
std::cout << "Benutzerdefinierte Ausnahme abgefangen: " << e.what() << std::endl;
}
return 0;
}
<stdexcept>Es ist eine wichtige Komponente der C++-Standardbibliothek. Sie bietet eine Reihe von Standard-Ausnahmeklassen, wodurch die Fehlerbehandlung konsistenter und vorhersehbarer wird. Durch die Verwendung dieser Ausnahmeklassen können Sie robusteren und wartbareren Code schreiben. Für Anfänger ist das Verständnis der grundlegenden Konzepte von Ausnahmen und ihrer Verwendung ...<stdexcept>Die darin enthaltenen Ausnahmeklassen sind sehr wichtig.