C++ Afhandeling van uitzonderingen: voorbeeld proberen, vangen, gooien

Wat is uitzonderingsafhandeling? C++?

Afhandeling van uitzonderingen in C++ biedt u een manier om met onverwachte omstandigheden, zoals runtimefouten, om te gaan. Wanneer zich dus 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 binnen dat codegedeelte een uitzonderlijke situatie voordoet, wordt er een uitzondering gegenereerd. Vervolgens neemt de uitzonderingshandler de controle over het programma over.

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

In deze C++ tutorial, je leert:

Waarom uitzonderingsafhandeling?

Hier vindt u de reden voor het gebruik van uitzonderingsafhandeling C++:

  • U scheidt uw foutverwerkingscode van uw normale code. De code wordt leesbaarder en gemakkelijker te onderhouden.
  • Functies kunnen de uitzonderingen verwerken die zij kiezen. Zelfs als een functie veel uitzonderingen genereert, kan deze er slechts enkele verwerken. De beller zal de niet-afgevangen uitzonderingen afhandelen.

Trefwoorden voor afhandeling van uitzonderingen

Afhandeling van uitzonderingen in C++ draait om deze drie trefwoorden:

  • Gooi– wanneer een programma een probleem tegenkomt, genereert het een uitzondering. Het trefwoord throw helpt het programma bij het uitvoeren van de throw.
  • vangst– een programma gebruikt een uitzonderingshandler om een ​​uitzondering op te vangen. Het wordt toegevoegd aan de sectie van een programma waar u het probleem moet oplossen. Het wordt gedaan met behulp van het trefwoord catch.
  • proberen– het try-blok identificeert het codeblok waarvoor bepaalde uitzonderingen worden geactiveerd. Het moet worden gevolgd door één/meer catch-blokken.

Stel dat een codeblok een uitzondering genereert. De uitzondering wordt opgevangen door een methode die gebruikmaakt van try-and-catch-trefwoorden. Het try/catch-blok moet code omringen die een uitzondering kan veroorzaken. 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-instructie 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 de door u 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;
}

Output:

Trefwoorden voor afhandeling van uitzonderingen

Hier is een screenshot van de code:

Trefwoorden voor afhandeling van uitzonderingen

Code Verklaring:

  1. Neem het iostream-headerbestand op in het programma om het te gebruiken functies.
  2. Neem het vectorheaderbestand op in het programma om de functies ervan te gebruiken.
  3. Neem de std-naamruimte in het programma op in de klassen zonder deze aan te roepen.
  4. Roep de functie main() aan. De programmalogica moet in de hoofdtekst worden toegevoegd.
  5. Maak een vector met de naam vec om gehele 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 reactie. Het wordt overgeslagen door de C++ compiler.
  9. Gebruik de try-instructie om een ​​uitzondering op te vangen. De { markeert het begin van de hoofdtekst van het try/catch-blok. De code die in de hoofdtekst wordt toegevoegd, wordt de beschermde code.
  10. 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.
  11. Einde van het hoofdgedeelte 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 opgemerkt.
  14. Einde van het lichaam van het vangblok.
  15. Het programma zou bij succesvolle uitvoering een waarde moeten retourneren.
  16. Einde van de hoofdtekst van de functie main().

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

Output:

Trefwoorden voor afhandeling van uitzonderingen

Hier is een screenshot van de code:

Trefwoorden voor afhandeling van uitzonderingen

Code Verklaring:

  1. Neem het iostream-headerbestand op in het programma om de functies ervan te gebruiken.
  2. Neem de std-naamruimte in het programma op in de klassen zonder deze aan te roepen.
  3. Maak een functie genaamd zeroDivision die twee gehele getallen als argument neemt, x en y. De functie moet een double-resultaat retourneren.
  4. Gebruik een if-instructie om te controleren of de waarde van het variabele-argument y 0 is. De { markeert het begin van de if-tekst.
  5. Het bericht dat moet worden geretourneerd/gegooid als y 0 is.
  6. Einde van de hoofdtekst van de if-instructie.
  7. De zeroDivision-functie moet de waarde x/y retourneren.
  8. Einde van de hoofdtekst van de zeroDivision-functie.
  9. Roep de methode main() aan. De { markeert het begin van deze methode.
  10. Declareer een integer-variabele en wijs deze de waarde 11 toe.
  11. Declareer een integer-variabele b en geef deze de waarde 0.
  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 hoofdtekst van het try/catch-blok. De code die in de hoofdtekst wordt toegevoegd, wordt de beschermde code.
  14. 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.
  15. Druk de waarde van variabele c af op de console.
  16. Einde van het hoofdgedeelte 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 bij succesvolle uitvoering een waarde moeten retourneren.
  21. Einde van de hoofdtekst van de functie main().

C++ Standaard uitzonderingen

C++ Standaard uitzonderingen

C++ wordt geleverd met een lijst met standaarduitzonderingen gedefinieerd in klas. Deze worden hieronder beschreven:

uitzondering Beschrijving
std::uitzondering Dit is een uitzondering en de bovenliggende klasse van alle standaarden C++ uitzonderingen.
std::bad_alloc Deze uitzondering wordt gegenereerd door een nieuw trefwoord.
std::slechte_cast Dit is een uitzondering die wordt gegenereerd door dynamic_cast.
std::bad_exception Een handig apparaat voor het afhandelen van onverwachte uitzonderingen in C++ 's.
std::bad_typeid Een uitzondering gegenereerd door typeid.
std::logische_fout Deze uitzondering is theoretisch detecteerbaar door code te lezen.
std::domein_fout Dit is een uitzondering die optreedt na gebruik van een wiskundig ongeldig domein.
std::ongeldig_argument Er is een uitzondering gegenereerd vanwege het gebruik van ongeldige argumenten.
std::lengte_fout Er is een uitzondering opgetreden na het maken van een grote std::string.
std::buiten_bereik Geworpen door de methode.
std::runtime_error Dit is een uitzondering die niet kan worden gedetecteerd via het lezen van de code.
std::overflow_error Deze uitzondering wordt gegenereerd na het optreden van een wiskundige overflow.
std::bereik_fout Deze uitzondering treedt op wanneer u probeert een waarde op te slaan die buiten het bereik valt.
std::underflow_error Een uitzondering die is gegenereerd na het optreden van een wiskundige onderstroom.

Door de gebruiker gedefinieerde uitzonderingen

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

Deze functie retourneert een op nul eindigende tekenreeks van het type char *. We kunnen het in afgeleide klassen overschrijven 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;	
}

Output:

Door de gebruiker gedefinieerde uitzonderingen

Hier is een screenshot van de code:

Door de gebruiker gedefinieerde uitzonderingen

Code Verklaring:

  1. Neem het iostream-headerbestand op in ons programma. We zullen de functies ervan gebruiken zonder fouten te krijgen.
  2. Neem het uitzonderingsheaderbestand op in ons programma. We zullen de functies zoals wat zonder fouten gebruiken.
  3. Neem de std-naamruimte op in ons programma om de klassen ervan 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 het klassenlichaam.
  6. Overschrijf de virtuele lidfunctie what() die is gedefinieerd in het uitzonderingsheaderbestand. Vervolgens zullen we onze eigen uitzondering beschrijven, de nieuwe uitzondering.
  7. Start de definitie van de nieuwe uitzondering.
  8. Het bericht dat moet worden geretourneerd als de nieuwe uitzondering wordt onderschept.
  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 zal worden aangeroepen.
  11. Roep de functie main() aan. De programmalogica moet in de hoofdtekst worden toegevoegd. De { markeert het begin van zijn lichaam.
  12. Gebruik een try-instructie om de code te markeren waarbinnen we de uitzondering moeten markeren. De { markeert het begin van de hoofdtekst van het try/catch-blok. De code die hierdoor wordt omgeven, wordt beschermd.
  13. Gooi de newex-uitzondering als deze wordt opgevangen.
  14. Einde van de try-body.
  15. Gebruik de catch-instructie 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 hoofdtekst van de catch-instructie.
  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 runtimefouten afhandelen.
  • Runtimefouten zijn de fouten die optreden tijdens de uitvoering van een programma.
  • Met de afhandeling van uitzonderingen kunt u omgaan met onverwachte omstandigheden in uw programma.
  • Wanneer de onverwachte omstandigheid zich voordoet, wordt de programmacontrole overgedragen aan handlers.
  • Om een ​​uitzondering op te vangen, plaatst u een codegedeelte onder het try-catch-blok.
  • Het trefwoord throw helpt het programma uitzonderingen te genereren, waardoor het programma het probleem kan oplossen.
  • Het try-trefwoord helpt bij het identificeren van het codeblok waarvoor bepaalde uitzonderingen worden geactiveerd.
  • We kunnen de what()-functie van het uitzonderingsheaderbestand overschrijven om onze uitzonderingen te definiëren.