C ++ Exception Handling: Try, Catch, throw Voorbeeld

Wat is het afhandelen van uitzonderingen in C ++?

Afhandeling van uitzonderingen in C ++ biedt u een manier om met onverwachte omstandigheden om te gaan, zoals runtime-fouten. Dus wanneer zich een onverwachte omstandigheid voordoet, wordt de programmabesturing overgedragen aan speciale functies die bekend staan als handlers.

Om de uitzonderingen op te vangen, plaatst u een deel van de code onder uitzonderingsinspectie. Het codegedeelte wordt in het try-catch-blok geplaatst.

Als zich een uitzonderlijke situatie voordoet binnen dat gedeelte van de code, wordt er een uitzondering gegenereerd. Vervolgens neemt de exception handler de controle over het programma over.

Als er zich geen uitzonderlijke omstandigheid voordoet, wordt de code normaal uitgevoerd. De handlers worden genegeerd.

In deze C ++ tutorial leer je:

Wat is het afhandelen van uitzonderingen in C ++?
Waarom afhandeling van uitzonderingen?
Trefwoorden voor het afhandelen van uitzonderingen
Syntaxis:
C ++ standaarduitzonderingen
Door de gebruiker gedefinieerde uitzonderingen

Waarom afhandeling van uitzonderingen?

Hier is de reden om Exception Handling te gebruiken in C ++:

U scheidt uw foutafhandelingscode van uw normale code. De code wordt beter leesbaar en gemakkelijker te onderhouden.
Functies kunnen omgaan met de uitzonderingen die ze kiezen. Zelfs als een functie veel uitzonderingen genereert, zal het er maar enkele aan kunnen. De beller zal de niet-afgevangen uitzonderingen afhandelen.

Trefwoorden voor het afhandelen van uitzonderingen

Het afhandelen van uitzonderingen in C ++ draait om deze drie sleutelwoorden:

throw - wanneer een programma een probleem tegenkomt, genereert het een uitzondering. Het worp-sleutelwoord helpt het programma de worp uit te voeren.
catch - een programma gebruikt een exception handler om een exception op te vangen. Het wordt toegevoegd aan het gedeelte van een programma waar u het probleem moet oplossen. Het is gedaan met behulp van het catch-trefwoord.
try - het try-blok identificeert het codeblok waarvoor bepaalde uitzonderingen worden geactiveerd. Het moet worden gevolgd door een / meer catch-blokken.

Stel dat een codeblok een uitzondering veroorzaakt. De uitzondering wordt opgevangen door een methode die 'try and catch'-trefwoorden gebruikt. Het try / catch-blok moet de code omringen die een uitzondering kan genereren. Een dergelijke code staat bekend als beschermde code.

Syntaxis:

De try / catch heeft deze syntaxis:

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

Hoewel we één try-statement hebben, kunnen we veel catch-statements hebben.
De ExceptionName is de naam van de uitzondering die moet worden opgevangen.
De uitzondering1, uitzondering2 en uitzonderingN zijn uw gedefinieerde namen om naar de uitzonderingen te verwijzen.

Voorbeeld 1:

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

Uitgang:

Hier is een screenshot van de code:

Code Verklaring:

Neem het iostream-headerbestand op in het programma om de functies ervan te gebruiken.
Neem het vectorkopbestand op in het programma om de functies ervan te gebruiken.
Neem de std-naamruimte in het programma op in de klassen zonder het op te roepen.
Roep de functie main () aan. De programmalogica moet in zijn lichaam worden toegevoegd.
Maak een vector met de naam vec om gegevens met gehele getallen op te slaan.
Voeg het element 0 toe aan de vector met de naam vec.
Voeg het element 1 toe aan de vector met de naam vec.
Een reactie. Het wordt overgeslagen door de C ++ - compiler.
Gebruik de instructie try om een uitzondering op te vangen. De {markeert het begin van de body van het try / catch-blok. De code die in de body wordt toegevoegd, wordt de beschermde code.
Probeer toegang te krijgen tot het element dat is opgeslagen in index 2 (derde element) van de vector met de naam vec. Dit element bestaat niet.
Einde van de body van het try / catch-blok.
Vang de uitzondering op. Het geretourneerde foutbericht wordt opgeslagen in de variabele ex.
Druk een bericht af op de console als de uitzondering wordt opgemerkt.
Einde van het lichaam van het vangblok.
Het programma zou een waarde moeten retourneren bij een succesvolle uitvoering.
Einde van de hoofdtekst () functie.

Voorbeeld 2:

#include 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;}

Uitgang:

Hier is een screenshot van de code:

Code Verklaring:

Neem het iostream-headerbestand op in het programma om de functies ervan te gebruiken.
Neem de std-naamruimte in het programma op in de klassen zonder het op te roepen.
Maak een functie met de naam zeroDivision waaraan twee integer-argumenten x en y moeten doorgegeven worden. De functie zou een dubbel resultaat moeten retourneren.
Gebruik een if-instructie om te controleren of de waarde van het variabele argument y 0 is. De {markeert het begin van de if body.
Het bericht dat moet worden geretourneerd / gegenereerd als y 0 is.
Einde van de body van de if-instructie.
De zeroDivision-functie moet de waarde van x / y retourneren.
Einde van de body van de zeroDivision-functie.
Roep de methode main () aan. De {markeert het begin van deze methode.
Declareer een integervariabele en wijs er de waarde 11 aan toe.
Declareer een integer-variabele b en wijs er de waarde 0 aan toe.
Declareer een dubbele variabele c en geef deze de waarde 0.
Gebruik de instructie try om een uitzondering op te vangen. De {markeert het begin van de body van het try / catch-blok. De code die in de body wordt toegevoegd, wordt de beschermde code.
Roep de zeroDivision-functie aan en geef de argumenten a en b door, dat wil zeggen 11 en 0. Het resultaat van deze bewerking wordt opgeslagen in variabele c.
Druk de waarde van variabele c af op de console.
Einde van de body van het try / catch-blok.
Vang de uitzondering op. Het geretourneerde foutbericht wordt opgeslagen in het variabele bericht.
Druk het geretourneerde foutbericht af op de console.
Einde van het lichaam van het vangblok.
Het programma zou een waarde moeten retourneren bij een succesvolle uitvoering.
Einde van de hoofdtekst () functie.

C ++ standaarduitzonderingen

C ++ wordt geleverd met een lijst met standaarduitzonderingen die zijn gedefinieerd in de klasse . Deze worden hieronder beschreven:

Uitzondering	Omschrijving
std :: uitzondering	Dit is een uitzondering en de bovenliggende klasse van alle standaard C ++ -uitzonderingen.
std :: bad_alloc	Deze uitzondering wordt veroorzaakt door een nieuw trefwoord.
std :: bad_cast	Dit is een uitzondering veroorzaakt door dynamic_cast.
std :: bad_exception	Een handig apparaat voor het omgaan met onverwachte uitzonderingen in C ++ - programma's.
std :: bad_typeid	Een uitzondering veroorzaakt door typeid.
std :: logic_error	Deze uitzondering is theoretisch detecteerbaar door code te lezen.
std :: domain_error	Dit is een uitzondering die wordt gegenereerd na het gebruik van een wiskundig ongeldig domein.
std :: invalid_argument	Er is een uitzondering opgetreden voor het gebruik van ongeldige argumenten.
std :: length_error	Er is een uitzondering opgetreden na het maken van een grote std :: string.
std :: out_of_range	Gegooid door bij methode.
std :: runtime_error	Dit is een uitzondering die niet kan worden gedetecteerd door het lezen van de code.
std :: overflow_error	Deze uitzondering wordt gegenereerd na het optreden van een wiskundige overflow.
std :: range_error	Deze uitzondering wordt gegenereerd wanneer u probeert een waarde op te slaan die buiten het bereik valt.
std :: underflow_error	Een uitzondering gegenereerd na het optreden van een wiskundige underflow.

Door de gebruiker gedefinieerde uitzonderingen

Met de klasse C ++ std :: exception kunnen we objecten definiëren die als uitzonderingen kunnen worden gegenereerd. Deze klasse is gedefinieerd in de header. De klasse biedt ons een virtuele ledenfunctie met de naam wat.

Deze functie retourneert een met null beëindigde tekenreeks van het type char *. We kunnen het overschrijven in afgeleide klassen om een uitzonderingsbeschrijving te hebben.

Voorbeeld:

#include #include 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;}

Uitgang:

Hier is een screenshot van de code:

Code Verklaring:

Neem het iostream-headerbestand op in ons programma. We zullen de functies ervan gebruiken zonder fouten te krijgen.
Neem het header-bestand van de uitzondering op in ons programma. We zullen de functies ervan gebruiken zoals wat zonder fouten.
Neem de std-naamruimte op in ons programma om zijn klassen te gebruiken zonder deze op te roepen.
Maak een nieuwe klasse met de naam newException. Deze klasse neemt de uitzonderingsklasse van C ++ over.
Het begin van het klassenlichaam.
Overschrijf de functie van het virtuele lid wat () is gedefinieerd in het header-bestand van de uitzondering. We zullen dan onze eigen uitzondering beschrijven, de nieuwe uitzondering.
Start de definitie van de nieuwe uitzondering.
Het bericht dat moet worden geretourneerd als de nieuwe uitzondering wordt opgemerkt.
Einde van de definitie van de nieuwe uitzondering.
Einde van de body van klasse newException. De newex is de naam die moet worden gebruikt om onze nieuwe exception op te vangen, waarna de newException wordt aangeroepen.
Roep de functie main () aan. De programmalogica moet in zijn lichaam worden toegevoegd. De {markeert het begin van zijn lichaam.
Gebruik een try-instructie om de code te markeren waarin we de uitzondering moeten markeren. De {markeert het begin van de body van het try / catch-blok. De code die hierdoor wordt omgeven, wordt beschermd.
Gooi de newex-uitzondering als deze is gepakt.
Einde van de try-body.
Gebruik de instructie catch om de uitzondering af te vangen. Het uitzonderingsfoutbericht wordt opgeslagen in variabele ex.
Druk het uitzonderingsfoutbericht af op de console.
Einde van de inhoud van de catch-instructie.
Het programma moet een waarde retourneren als het met succes wordt uitgevoerd.
Einde van de hoofdtekst van de functie main ().

Overzicht:

Met het afhandelen van uitzonderingen in C ++ kunt u runtimefouten afhandelen.
Runtimefouten zijn de fouten die optreden tijdens het uitvoeren van een programma.
Het afhandelen van uitzonderingen helpt u om met onverwachte omstandigheden in uw programma om te gaan.
Wanneer de onverwachte omstandigheid zich voordoet, wordt de programmabesturing overgedragen aan handlers.
Om een uitzondering op te vangen, plaats je een gedeelte van de code onder het blok try-catch.
Het throw-sleutelwoord helpt het programma uitzonderingen te genereren, waardoor het programma het probleem kan oplossen.
Het trefwoord try helpt bij het identificeren van het codeblok waarvoor bepaalde uitzonderingen worden geactiveerd.
We kunnen de what () functie van het exception header-bestand overschrijven om onze uitzonderingen te definiëren.