C++-Ausnahmebehandlung:Try, Catch, Throw Beispiel

Was ist Ausnahmebehandlung in C++?

Die Ausnahmebehandlung in C++ bietet Ihnen eine Möglichkeit, mit unerwarteten Umständen wie Laufzeitfehlern umzugehen. Wann immer also ein unerwarteter Umstand eintritt, wird die Programmsteuerung an spezielle Funktionen übertragen, die als Handler bekannt sind.

Um die Ausnahmen abzufangen, unterziehen Sie einen bestimmten Codeabschnitt der Ausnahmeprüfung. Der Codeabschnitt wird innerhalb des Try-Catch-Blocks platziert.

Wenn innerhalb dieses Codeabschnitts eine Ausnahmesituation auftritt, wird eine Ausnahme ausgelöst. Als nächstes übernimmt der Ausnahmehandler die Kontrolle über das Programm.

Falls keine Ausnahmesituation eintritt, wird der Code normal ausgeführt. Die Handler werden ignoriert.

In diesem C++-Tutorial lernen Sie:

• Was ist Ausnahmebehandlung in C++?
• Warum Ausnahmebehandlung?
• Schlüsselwörter zur Ausnahmebehandlung
• Syntax:
• C++-Standardausnahmen
• Benutzerdefinierte Ausnahmen

Warum Ausnahmebehandlung?

Hier sind die Gründe für die Verwendung der Ausnahmebehandlung in C++:

• Sie werden Ihren Fehlerbehandlungscode von Ihrem normalen Code trennen. Der Code wird besser lesbar und einfacher zu warten sein.
• Funktionen können die von ihnen gewählten Ausnahmen behandeln. Selbst wenn eine Funktion viele Ausnahmen auslöst, behandelt sie nur einige. Der Aufrufer behandelt die nicht abgefangenen Ausnahmen.

Schlüsselwörter zur Ausnahmebehandlung

Die Ausnahmebehandlung in C++ dreht sich um diese drei Schlüsselwörter:

• werfen – Wenn ein Programm auf ein Problem stößt, löst es eine Ausnahme aus. Das Schlüsselwort throw hilft dem Programm, den Throw auszuführen.
• fangen – Ein Programm verwendet einen Ausnahmebehandler, um eine Ausnahme abzufangen. Es wird dem Abschnitt eines Programms hinzugefügt, in dem Sie das Problem behandeln müssen. Dies geschieht mit dem Schlüsselwort catch.
• versuchen – Der try-Block identifiziert den Codeblock, für den bestimmte Ausnahmen aktiviert werden. Es sollten ein oder mehrere catch-Blöcke folgen.

Angenommen, ein Codeblock löst eine Ausnahme aus. Die Ausnahme wird von einer Methode abgefangen, die try- und catch-Schlüsselwörter verwendet. Der Try/Catch-Block sollte Code umgeben, der möglicherweise eine Ausnahme auslöst. Dieser Code wird als geschützter Code bezeichnet.

Syntax:

Try/Catch hat diese Syntax:

try {
   // the protected code
} catch( Exception_Name exception1 ) {
   // catch block
} catch( Exception_Name exception2 ) {
   // catch block
} catch( Exception_Name exceptionN ) {
   // catch block
}

• Obwohl wir eine try-Anweisung haben, können wir viele catch-Anweisungen haben.
• Der ExceptionName ist der Name der abzufangenden Ausnahme.
• Ausnahme1, Ausnahme2 und AusnahmeN sind Ihre definierten Namen zum Verweisen auf die Ausnahmen.

Beispiel 1:

#include<iostream>
#include<vector>
using namespace std;

int main() {
	vector<int> vec;
	vec.push_back(0);	
	vec.push_back(1);	
	// access the third element, which doesn't exist
	try
	{
		vec.at(2);		
	}
	catch (exception& ex)
	{
		cout << "Exception occurred!" << endl;
	}
	return 0;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Schließen Sie die iostream-Header-Datei in das Programm ein, um seine Funktionen zu nutzen.
2. Fügen Sie die Vektor-Header-Datei in das Programm ein, um seine Funktionen zu nutzen.
3. Fügen Sie den std-Namensraum in das Programm in seine Klassen ein, ohne es aufzurufen.
4. Rufen Sie die Funktion main() auf. Die Programmlogik sollte in ihrem Körper hinzugefügt werden.
5. Erstellen Sie einen Vektor namens vec, um Integer-Daten zu speichern.
6. Füge das Element 0 zum Vektor namens vec hinzu.
7. Fügen Sie das Element 1 zum Vektor namens vec hinzu.
8. Ein Kommentar. Sie wird vom C++-Compiler übersprungen.
9. Verwenden Sie die try-Anweisung, um eine Ausnahme abzufangen. Das { markiert den Anfang des Hauptteils des try/catch-Blocks. Der im Text hinzugefügte Code wird zum geschützten Code.
10. Versuchen Sie, auf das Element zuzugreifen, das an Index 2 (drittes Element) des Vektors namens vec gespeichert ist. Dieses Element existiert nicht.
11. Ende des Rumpfes des Try/Catch-Blocks.
12. Fangen Sie die Ausnahme ab. Die zurückgegebene Fehlermeldung wird in der Variablen ex gespeichert.
13. Eine Meldung auf der Konsole ausgeben, wenn die Ausnahme abgefangen wird.
14. Ende des Körpers des catch-Blocks.
15. Das Programm sollte bei erfolgreicher Ausführung einen Wert zurückgeben.
16. Ende des Hauptteils der main()-Funktion.

Beispiel 2:

#include <iostream>
using namespace std;
double zeroDivision(int x, int y) {

	if (y == 0) {
		throw "Division by Zero!";
	}
	return (x / y);
}

int main() {
	int a = 11;
	int b = 0;
	double c = 0;

	try {
		c = zeroDivision(a, b);
		cout << c << endl;
	}
	catch (const char* message) {
		cerr << message << endl;
	}
	return 0;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Schließen Sie die iostream-Header-Datei in das Programm ein, um seine Funktionen zu nutzen.
2. Fügen Sie den std-Namensraum in das Programm in seine Klassen ein, ohne es aufzurufen.
3. Erstellen Sie eine Funktion namens zeroDivision, die zwei ganzzahlige Argumente, x und y, akzeptiert. Die Funktion sollte ein doppeltes Ergebnis zurückgeben.
4. Verwenden Sie eine if-Anweisung, um zu prüfen, ob der Wert des Variablenarguments y 0 ist. Das { markiert den Anfang des if-Körpers.
5. Die Nachricht, die zurückgegeben/geworfen werden soll, wenn y gleich 0 ist.
6. Ende des Hauptteils der if-Anweisung.
7. Die zeroDivision-Funktion sollte den Wert von x/y zurückgeben.
8. Ende des Hauptteils der Funktion zeroDivision.
9. Rufen Sie die Methode main() auf. Das { markiert den Beginn dieser Methode.
10. Deklarieren Sie eine Integer-Variable und weisen Sie ihr den Wert 11 zu.
11. Deklarieren Sie eine Integer-Variable b und weisen Sie ihr den Wert 0 zu.
12. Deklarieren Sie eine Double-Variable c und weisen Sie ihr den Wert 0 zu.
13. Verwenden Sie die try-Anweisung, um eine Ausnahme abzufangen. Das { markiert den Anfang des Hauptteils des try/catch-Blocks. Der im Text hinzugefügte Code wird zum geschützten Code.
14. Aufruf der Funktion zeroDivision und Übergabe an die Argumente a und b, also 11 und 0. Das Ergebnis dieser Operation wird in Variable c gespeichert.
15. Den Wert der Variable c auf der Konsole ausgeben.
16. Ende des Rumpfes des Try/Catch-Blocks.
17. Fangen Sie die Ausnahme ab. Die zurückgegebene Fehlermeldung wird in der Variable message gespeichert.
18. Drucken Sie die zurückgegebene Fehlermeldung auf der Konsole aus.
19. Ende des Körpers des catch-Blocks.
20. Das Programm sollte bei erfolgreicher Ausführung einen Wert zurückgeben.
21. Ende des Hauptteils der main()-Funktion.

C++-Standardausnahmen

C++ enthält eine Liste von Standardausnahmen, die in der Klasse definiert sind. Diese werden im Folgenden beschrieben:

Ausnahme Beschreibung std::exceptionDies ist eine Ausnahme und die übergeordnete Klasse aller standardmäßigen C++-Ausnahmen.std::bad_allocDiese Ausnahme wird von einem neuen Schlüsselwort ausgelöst.std::bad_castDies ist eine Ausnahme, die von dynamic_cast ausgelöst wird.std::bad_exceptionEin nützliches Gerät zur Behandlung unerwarteter Ausnahmen in C++-Programmen.std::bad_typeidEine Ausnahme, die von typeid.std::logic_error ausgelöst wird.Diese Ausnahme kann theoretisch durch Lesen von code.std::domain_error erkannt werden.Dies ist eine Ausnahme, die nach der Verwendung einer mathematisch ungültigen Domäne ausgelöst wird.std::invalid_argumentEine Ausnahme, die wegen der Verwendung ungültiger Argumente ausgelöst wird .std::length_errorEine Ausnahme, die nach dem Erstellen eines großen std::string.std::out_of_rangeThrown by at method.std::runtime_errorausgeworfen wirdDies ist eine Ausnahme, die nicht durch Lesen des Codes erkannt werden kann.std::overflow_errorDiese Ausnahme wird nach dem Auftreten ausgelöst eines mathematischen Überlaufs.std::range_errorDiese Ausnahme wird ausgelöst, wenn Sie versuchen, einen Wert außerhalb des zulässigen Bereichs zu speichern.std::underflow_errorEine Ausnahme, die nach dem Auftreten von m ausgelöst wird athematischer Unterlauf.

Benutzerdefinierte Ausnahmen

Die C++-Klasse std::exception ermöglicht es uns, Objekte zu definieren, die als Ausnahmen ausgelöst werden können. Diese Klasse wurde im Header definiert. Die Klasse stellt uns eine virtuelle Elementfunktion namens what zur Verfügung.

Diese Funktion gibt eine nullterminierte Zeichenfolge vom Typ char * zurück. Wir können es in abgeleiteten Klassen überschreiben, um eine Ausnahmebeschreibung zu erhalten.

Beispiel:

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

class newException : public exception
{
	virtual const char* what() const throw()
	{
		return "newException occurred";
	}
} newex;

int main() {

	try {
		throw newex;
		}
	catch (exception& ex) {
		cout << ex.what() << '\n';
	}
	return 0;	
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Fügen Sie die iostream-Header-Datei in unser Programm ein. Wir werden seine Funktionen verwenden, ohne Fehler zu erhalten.
2. Fügen Sie die Ausnahme-Header-Datei in unser Programm ein. Wir werden seine Funktionen wie fehlerfrei verwenden.
3. Fügen Sie den std-Namensraum in unser Programm ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
4. Erstellen Sie eine neue Klasse namens newException. Diese Klasse erbt die Ausnahmeklasse von C++.
5. Der Beginn des Klassenkörpers.
6. Überschreiben Sie die virtuelle Elementfunktion what(), die in der Ausnahme-Header-Datei definiert ist. Anschließend beschreiben wir unsere eigene Ausnahme, die neue Ausnahme.
7. Starten Sie die Definition der neuen Ausnahme.
8. Die Nachricht, die zurückgegeben werden soll, wenn die neue Ausnahme abgefangen wird.
9. Ende der Definition der neuen Ausnahme.
10. Ende des Hauptteils der Klasse newException. Der newex ist der Name, der verwendet werden soll, um unsere neue Ausnahme abzufangen, wonach die newException aufgerufen wird.
11. Rufen Sie die Funktion main() auf. Die Programmlogik sollte in ihrem Körper hinzugefügt werden. Das { markiert den Anfang seines Körpers.
12. Verwenden Sie eine try-Anweisung, um den Code zu markieren, in dem wir die Ausnahme markieren müssen. Das { markiert den Anfang des Hauptteils des try/catch-Blocks. Der davon umgebene Code wird geschützt.
13. Werfen Sie die newex-Ausnahme aus, wenn sie abgefangen wird.
14. Ende des Try-Body.
15. Verwenden Sie die catch-Anweisung, um die Ausnahme abzufangen. Die Ausnahmefehlermeldung wird in der Variablen ex gespeichert.
16. Drucken Sie die Ausnahmefehlermeldung auf der Konsole.
17. Ende des Hauptteils der catch-Anweisung.
18. Das Programm sollte einen Wert zurückgeben, wenn es erfolgreich ausgeführt wird.
19. Ende des Hauptteils der Funktion main().

Zusammenfassung:

• Mit der Ausnahmebehandlung in C++ können Sie Laufzeitfehler behandeln.
• Laufzeitfehler sind die Fehler, die während der Programmausführung auftreten.
• Die Ausnahmebehandlung hilft Ihnen, mit unerwarteten Umständen in Ihrem Programm umzugehen.
• Wenn der unerwartete Umstand eintritt, wird die Programmsteuerung an Handler übertragen.
• Um eine Ausnahme abzufangen, platzieren Sie einen Codeabschnitt unter dem Try-Catch-Block.
• Das throw-Schlüsselwort hilft dem Programm, Ausnahmen auszulösen, und hilft dem Programm, das Problem zu handhaben.
• Das Schlüsselwort try hilft dabei, den Codeblock zu identifizieren, für den bestimmte Ausnahmen aktiviert werden.
• Wir können die what()-Funktion der Ausnahme-Header-Datei überschreiben, um unsere Ausnahmen zu definieren.