Beispiel 1:
Hier ist der „iostream“ enthalten, die Header-Datei, in der mehrere Funktionen deklariert sind. Wir verwenden diese Funktionen, die in dieser Header-Datei deklariert sind, in unserem Code, also schließen wir diese Header-Datei ein. Danach haben wir den „std“, der hier platziert wird, da darin auch Funktionen wie „cin“ und „cout“ definiert sind. Wir müssen bei all diesen Funktionen nicht „std“ eingeben, wenn wir den „Namespace std“ am Anfang unseres Codes hinzufügen. Anschließend wird hier die Funktion „main()“ aufgerufen, die auch als Treibercode des C++-Programms bezeichnet wird.
Dann verwenden wir hier das Schlüsselwort „try“, in dem wir „my_num1“ mit dem Wert „35“ initialisieren. Es handelt sich hier um die Datentypvariable „int“. Jetzt platzieren wir diese Variable in „if“ und platzieren eine Bedingung, die besagt, dass „my_num1“ größer oder gleich „98“ sein muss. Wenn die gegebene Bedingung erfüllt ist, geht es innerhalb von „if“ weiter und führt die hier geschriebene Anweisung aus. Wir verwenden „cout“ und fügen eine Meldung ein, die angezeigt wird, wenn die Bedingung erfüllt ist.
Danach verwenden wir das Schlüsselwort „throw“, nachdem wir „else“ platziert haben. In diesem „throw“-Schlüsselwort übergeben wir „my_num1“ als Parameter. Darunter fügen wir den Teil „catch“ hinzu. Wir fügen „my_num2“ als Parameter von „catch()“ ein und verwenden dann „cout“ erneut innerhalb dieses „catch“-Teils. Dieser Teil wird nur ausgeführt, wenn im „try“-Teil eine Ausnahme auftritt.
Code 1:
#include
verwenden Namensraum std ;
int hauptsächlich ( ) {
versuchen {
int meine_num1 = 35 ;
Wenn ( meine_num1 >= 98 ) {
cout << „Der Zugang wird hier gewährt.“ ;
} anders {
werfen ( meine_num1 ) ;
}
}
fangen ( int meine_num2 ) {
cout << „Der Zugriff wird hier verweigert.“ << endl ;
cout << 'Die Nummer lautet: ' << meine_num2 ;
}
zurückkehren 0 ;
}
Ausgabe:
Die von uns eingegebene Zahl ist „35“, was kleiner als „98“ ist. Dort tritt also die Ausnahme auf und der Teil „catch()“ wird angezeigt. Der Zugriff auf den „try“-Teil wird verweigert.
Beispiel 2:
Wir platzieren hier die Header-Datei „iostream“ und den „namespace std“. Danach erstellen wir eine Funktion „division()“, in der wir zwei Parameter platzieren, nämlich den „Zähler“ und den „Nenner“ des Datentyps „int“. Wir setzen den Datentyp dieser „Division“-Funktion auf „double“.
Darunter fügen wir „if()“ hinzu, wobei wir die Bedingung hinzufügen, dass der Nenner gleich Null ist. Danach verwenden wir das Schlüsselwort „throw“ und geben dort eine Nachricht ein. Diese Nachricht wird immer dann gerendert, wenn in diesem Code entsprechend der Bedingung eine Ausnahme auftritt. Darunter verwenden wir das Schlüsselwort „return“, in das wir „Zähler/Nenner“ einfügen. Es gibt also das Ergebnis der Division zurück. Nun wird die Funktion „main()“ aufgerufen.
Danach werden „num1“ und „num2“ als „int“-Variablen initialisiert und ihnen „89“ bzw. „0“ zugewiesen. Anschließend initialisieren wir das „Ergebnis“ des Datentyps „double“. Hier verwenden wir das Schlüsselwort „try“. In diesem Teil fügen wir diese Variable „result“ hinzu und weisen dieser Variablen die Funktion „division()“ zu. Wir übergeben dieser Funktion zwei Parameter: „num1“ und „num2“. Darunter zeigen wir das „Ergebnis“ an, das wir nach Anwendung der Funktion „division()“ erhalten. Danach nutzen wir auch den „catch“ und platzieren den „const char* msg“, um die Nachricht anzuzeigen, die wir zuvor hinzugefügt haben.
Code 2:
#includeverwenden Namensraum std ;
doppelt Aufteilung ( int Zähler, int Nenner ) {
Wenn ( Nenner == 0 ) {
werfen „Eine Division durch Null ist hier nicht möglich!“ ;
}
zurückkehren ( Zähler / Nenner ) ;
}
int hauptsächlich ( ) {
int num1 = 89 ;
int num2 = 0 ;
doppelt Ergebnis = 0 ;
versuchen {
Ergebnis = Aufteilung ( num1, num2 ) ;
cout << Ergebnis << endl ;
} fangen ( const verkohlen * Nachricht ) {
cerr << Nachricht << endl ;
}
zurückkehren 0 ;
}
Ausgabe:
Die Zahl, die wir zuvor als Nenner eingegeben haben, ist „0“. Die Ausnahme tritt also im Code auf und zeigt die angegebene Meldung an.
Beispiel 3:
Hier entsteht die Funktion „multiplication()“, in der wir „value“ und „multiplier“ als Parameter des Datentyps „int“ platzieren. Dann verwenden wir „if“, indem wir eine Multiplikatorbedingung hinzufügen, die gleich Null ist. Dann wird „throw“ dort platziert, wo wir eine Anweisung hinzufügen. Dann haben wir die „Rückgabe“, in der wir die zuvor deklarierten „Wert * Multiplikator“-Variablen platzieren. Daher wird hier das Multiplikationsergebnis zurückgegeben.
Danach rufen wir „main()“ auf, wo wir „int value1“ und „int value2“ mit den Werten „34“ bzw. „0“ deklarieren. Hier wird auch die Funktion „int m_res“ deklariert und dann die Funktion „multiplication()“ aufgerufen. Nach Ausführung dieser Funktion wird nun das Ergebnis in der Variablen „m_res“ gespeichert und anschließend angezeigt. Anschließend verwenden wir die „catch“-Funktion und fügen „const char* msg“ ein, um die Nachricht anzuzeigen, die wir zuvor im „throw“-Teil hinzugefügt haben.
Code 3:
#includeverwenden Namensraum std ;
doppelt Multiplikation ( int Wert , int Multiplikator ) {
Wenn ( Multiplikator == 0 ) {
werfen „Wir multiplizieren den Wert nicht mit Null!“ ;
}
zurückkehren ( Wert * Multiplikator ) ;
}
int hauptsächlich ( ) {
int Wert1 = 3. 4 ;
int Wert2 = 0 ;
int m_res ;
versuchen {
m_res = Multiplikation ( Wert1, Wert2 ) ;
cout << m_res << endl ;
} fangen ( const verkohlen * Nachricht ) {
cerr << Nachricht << endl ;
}
zurückkehren 0 ;
}
Ausgabe :
Da der Wert, den wir zuvor eingegeben haben, als Multiplikator „0“ hat, gibt es im Code eine Ausnahme, die dazu führt, dass der Hinweis hier angezeigt wird.
Beispiel 4:
Hier erstellen wir die Funktion „multiply()“ und übergeben „number1“ und „number2“ als Parameter des Datentyps „int“. Als nächstes verwenden wir den „if“-Operator, um eine Bedingung hinzuzufügen, bei der es sich um einen Multiplikator handelt, der kleiner oder gleich Null ist. Danach wird die Aussage dort eingefügt, wo „throw“ stehen soll. Das Multiplikationsergebnis wird dann im Abschnitt „return“ zurückgegeben, wo wir die Variable „number1 * number2“ einfügen, die wir zuvor deklariert haben.
Anschließend rufen wir die Funktion „main()“ auf und weisen „int newNumber1“ bzw. „int newNumber2“ die Werte „34“ und „12“ zu. Hier wird die Funktion „multiply()“ nach der Deklaration des „int mResult“ aufgerufen. Das Ergebnis dieser Funktion wird nun in der Variablen „mResult“ gespeichert und im Folgenden gerendert. Anschließend verwenden wir die Funktion „catch“ und fügen „const char* msg“ hinzu, um die Nachricht anzuzeigen, die wir im Abschnitt „throw“ geschrieben haben.
Code 4:
#includeverwenden Namensraum std ;
doppelt multiplizieren ( int Nummer 1 , int Nummer 2 ) {
Wenn ( Nummer 2 <= 0 ) {
werfen „Wir multiplizieren den Wert nicht mit Null oder einem negativen Wert!“ ;
}
zurückkehren ( Nummer 1 * Nummer 2 ) ;
}
int hauptsächlich ( ) {
int newNum1 = 3. 4 ;
int newNum2 = 12 ;
int mErgebnis ;
versuchen {
mErgebnis = multiplizieren ( neueNum1, neueNum2 ) ;
cout << „Das Ergebnis der Multiplikation ist“ << mErgebnis << endl ;
}
fangen ( const verkohlen * Nachricht ) {
cerr << Nachricht << endl ;
}
zurückkehren 0 ;
}
Ausgabe:
Der Wert, den wir hinzufügen, ist „12“, zu dem wir die Bedingung hinzufügen. Daher wird die Funktion „multiply()“ ausgeführt, da die Bedingung nicht wahr ist. Das Ergebnis der Multiplikation wird angezeigt. Der „try“-Teil wird hier ausgeführt.
Abschluss
Das „Try-Catch“-Konzept und die Codes in diesem Leitfaden werden im Detail untersucht. Wir haben dieses „Try-Catch“-Konzept gründlich untersucht und gezeigt, wie es in der C++-Programmierung funktioniert. Wir haben definiert, dass der Begriff „throw“ eine Ausnahme erzeugt, wenn ein Fehler gefunden wird, der es uns ermöglicht, unseren eindeutigen Code zu schreiben. Mithilfe des „catch“-Ausdrucks können wir einen Codeblock angeben, der ausgeführt werden soll, wenn im „try“-Teil eine Ausnahme auftritt.