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 onverwachte omstandigheden zoals runtime-fouten af ​​te handelen. 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 zich geen uitzonderlijke omstandigheid voordoet, wordt de code normaal uitgevoerd. De begeleiders worden genegeerd.

In deze C++ tutorial leer je:

• Wat is het afhandelen van uitzonderingen in C++?
• Waarom afhandeling van uitzonderingen?
• Trefwoorden omgaan met uitzonderingen
• Syntaxis:
• C++ standaard uitzonderingen
• Door de gebruiker gedefinieerde uitzonderingen

Waarom afhandeling van uitzonderingen?

Dit zijn de redenen voor het gebruik van Exception Handling in C++:

• U scheidt uw foutafhandelingscode van uw normale code. De code wordt beter leesbaar en gemakkelijker te onderhouden.
• Functies kunnen de door hen gekozen uitzonderingen aan. Zelfs als een functie veel uitzonderingen genereert, zal deze er slechts enkele afhandelen. De beller zal de niet-afgevangen uitzonderingen afhandelen.

Trefwoorden omgaan met uitzonderingen

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

• gooien - wanneer een programma een probleem tegenkomt, genereert het een uitzondering. Het worp trefwoord helpt het programma de worp uit te voeren.
• vangen – 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-sleutelwoord.
• probeer – het try-blok identificeert het codeblok waarvoor bepaalde uitzonderingen worden geactiveerd. Het moet worden gevolgd door een/meer vangstblokken.

Stel dat een codeblok een uitzondering genereert. De uitzondering wordt opgevangen door een methode die try-and-cat-trefwoorden gebruikt. Het try/catch-blok moet de code omringen die een uitzondering kan veroorzaken. Een dergelijke code staat bekend als beveiligde 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 exception1, exception2 en exceptionN zijn uw gedefinieerde namen om naar de uitzonderingen te verwijzen.

Voorbeeld 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;
}

Uitvoer:

Hier is een screenshot van de code:

Code uitleg:

1. Voeg het iostream-headerbestand toe aan het programma om de functies ervan te gebruiken.
2. Voeg het vectorheaderbestand toe aan het programma om de functies ervan te gebruiken.
3. Voeg de std-naamruimte toe aan de klassen van het programma zonder deze aan te roepen.
4. Roep de functie main() aan. De programmalogica moet in de body worden toegevoegd.
5. Maak een vector met de naam vec om integer-gegevens op te slaan.
6. Voeg het element 0 toe aan de vector met de naam vec.
7. Voeg het element 1 toe aan de vector met de naam vec.
8. Een opmerking. Het wordt overgeslagen door de C++-compiler.
9. Gebruik de try-instructie 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.
10. Probeer toegang te krijgen tot het element dat is opgeslagen op index 2 (derde element) van de vector met de naam vec. Dit element bestaat niet.
11. Einde van de body van het try/catch-blok.
12. Vang de uitzondering. De geretourneerde foutmelding wordt opgeslagen in de variabele ex.
13. Druk een bericht af op de console als de uitzondering wordt opgevangen.
14. Einde van het lichaam van het vangblok.
15. Het programma zou een waarde moeten retourneren na succesvolle uitvoering.
16. Einde van de hoofdtekst van de functie ().

Voorbeeld 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;
}

Uitvoer:

Hier is een screenshot van de code:

Code uitleg:

1. Voeg het iostream-headerbestand toe aan het programma om de functies ervan te gebruiken.
2. Voeg de std-naamruimte toe aan de klassen van het programma zonder deze aan te roepen.
3. 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.
4. Gebruik een if-statement om te controleren of de waarde van het variabele argument y 0 is. De { markeert het begin van if body.
5. Het bericht dat moet worden geretourneerd/gegooid als y 0 is.
6. Einde van de hoofdtekst van het if-statement.
7. De functie zeroDivision moet de waarde x/y teruggeven.
8. Einde van de hoofdtekst van de functie zeroDivision.
9. Roep de methode main() aan. De { markeert het begin van deze methode.
10. Declareer een integer-variabele en ken deze de waarde 11 toe.
11. Declareer een integer-variabele b en ken deze de waarde 0 toe.
12. Declareer een dubbele variabele c en ken deze de waarde 0 toe.
13. Gebruik de try-instructie 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.
14. Roep de functie zeroDivision aan en geef deze door aan argumenten a en b, dat wil zeggen 11 en 0. Het resultaat van deze bewerking wordt opgeslagen in variabele c.
15. Druk de waarde van variabele c af op de console.
16. Einde van de body van het try/catch-blok.
17. Vang de uitzondering. Het geretourneerde foutbericht wordt opgeslagen in het variabele bericht.
18. Druk het geretourneerde foutbericht af op de console.
19. Einde van het lichaam van het vangblok.
20. Het programma zou een waarde moeten retourneren na succesvolle uitvoering.
21. Einde van de hoofdtekst van de functie ().

C++ standaard uitzonderingen

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

Uitzondering Beschrijving std::exceptionDit is een uitzondering en de bovenliggende klasse van alle standaard C++-uitzonderingen.std::bad_allocDeze uitzondering wordt gegenereerd door een nieuw trefwoord.std::bad_castDit is een uitzondering die wordt gegenereerd door dynamic_cast.std::bad_exceptionEen handig apparaat voor het afhandelen van onverwachte uitzonderingen in C++ programmes.std::bad_typeidEen uitzondering gegenereerd door typeid.std::logic_errorDeze uitzondering is theoretisch detecteerbaar door het lezen van code.std::domain_errorDit is een uitzondering die wordt gegenereerd na het gebruik van een wiskundig ongeldig domein.std::invalid_argumentEen uitzondering die wordt gegenereerd voor het gebruik van ongeldige argumenten .std::length_errorEen uitzondering die wordt gegenereerd na het maken van een grote std::string.std::out_of_rangeThrown by at method.std::runtime_errorDit is een uitzondering die niet kan worden gedetecteerd via het lezen van de code.std::overflow_errorDeze uitzondering wordt gegenereerd na het optreden van een wiskundige overflow.std::range_errorDeze uitzondering wordt gegenereerd wanneer u probeert een waarde buiten het bereik op te slaan.std::underflow_errorEen uitzondering die wordt gegenereerd na het optreden van m athematische onderstroom.

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 lidfunctie met de naam wat.

Deze functie retourneert een op null eindigende tekenreeks van het type char *. We kunnen het overschrijven in afgeleide klassen om een ​​uitzonderingsbeschrijving te hebben.

Voorbeeld:

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

Uitvoer:

Hier is een screenshot van de code:

Code uitleg:

1. Neem het iostream-headerbestand op in ons programma. We zullen de functies ervan gebruiken zonder fouten te krijgen.
2. Neem het exception header-bestand op in ons programma. We zullen de functies gebruiken zoals wat zonder fouten.
3. Neem de std-naamruimte op in ons programma om de klassen te gebruiken zonder deze aan te roepen.
4. Maak een nieuwe klasse met de naam newException. Deze klasse erft de uitzonderingsklasse van C++.
5. Het begin van de klas.
6. Overschrijf de virtuele lidfunctie wat() gedefinieerd in het uitzonderingsheaderbestand. We zullen dan onze eigen uitzondering, de nieuwe uitzondering, beschrijven.
7. Start de definitie van de nieuwe uitzondering.
8. Het bericht dat moet worden geretourneerd als de nieuwe uitzondering wordt opgevangen.
9. Einde van de definitie van de nieuwe uitzondering.
10. Einde van de hoofdtekst van de klasse newException. De newex is de naam die moet worden gebruikt om onze nieuwe uitzondering op te vangen, waarna de newException wordt aangeroepen.
11. Roep de functie main() aan. De programmalogica moet in de body worden toegevoegd. De { markeert het begin van zijn lichaam.
12. Gebruik een try-statement 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 eromheen wordt beveiligd.
13. Gooi de newex-uitzondering als deze wordt gepakt.
14. Einde van de try-body.
15. Gebruik het catch-statement om de uitzondering op te vangen. Het uitzonderingsfoutbericht wordt opgeslagen in variabele ex.
16. Druk het uitzonderingsfoutbericht af op de console.
17. Einde van de body of catch-statement.
18. Het programma zou een waarde moeten retourneren als het succesvol wordt uitgevoerd.
19. Einde van de hoofdtekst van de functie main().

Samenvatting:

• Met uitzonderingsafhandeling in C++ kunt u runtime-fouten afhandelen.
• Runtime-fouten zijn de fouten die optreden tijdens de uitvoering van het programma.
• Het afhandelen van uitzonderingen helpt u bij het omgaan met onverwachte omstandigheden in uw programma.
• Wanneer de onverwachte omstandigheid zich voordoet, wordt de programmacontrole overgedragen aan de handlers.
• Om een ​​uitzondering op te vangen, plaats je een stuk code onder het try-catch-blok.
• Het throw-sleutelwoord helpt het programma om uitzonderingen te genereren, waardoor het programma het probleem kan oplossen.
• Het try-sleutelwoord 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 exceptions te definiëren.