C++ Undantagshantering: Prova, fånga, kasta Exempel

Om en exceptionell situation inträffar inom det avsnittet av koden, kommer ett undantag att kastas. Därefter kommer undantagshanteraren att ta över kontrollen över programmet.

Om inga exceptionella omständigheter inträffar kommer koden att köras normalt. Hanterarna kommer att ignoreras.

I detta C++ tutorial, du kommer att lära dig:

Varför undantagshantering?

Här är anledningen till att du använder Exception Handling in C++:

• Du kommer att separera din felhanteringskod från din vanliga kod. Koden blir mer läsbar och lättare att underhålla.
• Funktioner kan hantera de undantag de väljer. Även om en funktion ger många undantag, kommer den bara att hantera några. Den som ringer kommer att hantera de oupptäckta undantagen.

Undantagshantering av sökord

Undantagshantering i C++ kretsar kring dessa tre nyckelord:

• kasta– när ett program stöter på ett problem skapar det ett undantag. Nyckelordet kast hjälper programmet att utföra kast.
• fångst– ett program använder en undantagshanterare för att fånga ett undantag. Det läggs till i avsnittet i ett program där du behöver hantera problemet. Det görs med nyckelordet catch.
• prova– försöksblocket identifierar kodblocket för vilket vissa undantag kommer att aktiveras. Den ska följas av ett/fler fångstblock.

Anta att ett kodblock ger upphov till ett undantag. Undantaget kommer att fångas upp av en metod som använder try and catch-sökord. Try/catch-blocket bör omge kod som kan orsaka ett undantag. Sådan kod är känd som skyddad kod.

syntax

Try/catch tar denna syntax:

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

• Även om vi har ett försök, kan vi ha många fångstsatser.
• ExceptionName är namnet på undantaget som ska fångas upp.
• Undantag1, undantag2 och undantagN är dina definierade namn för att referera till undantagen.

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

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Inkludera iostream-huvudfilen i programmet för att använda dess funktioner.
2. Inkludera vektorhuvudfilen i programmet för att använda dess funktioner.
3. Inkludera std-namnområdet i programmet till dess klasser utan att anropa det.
4. Anropa main()-funktionen. Programlogiken bör läggas till i dess kropp.
5. Skapa en vektor med namnet vec för att lagra heltalsdata.
6. Lägg till elementet 0 till vektorn som heter vec.
7. Lägg till elementet 1 till vektorn som heter vec.
8. En kommentar. Det kommer att hoppas över av C++ kompilator.
9. Använd try-satsen för att fånga ett undantag. { markerar början av brödtexten i försök/fånga-blocket. Koden som läggs till i kroppen blir den skyddade koden.
10. Försök att komma åt elementet lagrat i index 2 (tredje elementet) av vektorn som heter vec. Detta element finns inte.
11. Slutet på kroppen av försök/fånga blocket.
12. Fånga undantaget. Det returnerade felmeddelandet kommer att lagras i variabeln ex.
13. Skriv ut något meddelande på konsolen om undantaget upptäcks.
14. Änden av spärrblockets kropp.
15. Programmet bör returnera ett värde vid framgångsrikt genomförande.
16. Slutet på huvuddelen () funktion.

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

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Inkludera iostream-huvudfilen i programmet för att använda dess funktioner.
2. Inkludera std-namnområdet i programmet till dess klasser utan att anropa det.
3. Skapa en funktion som heter zeroDivision som tar två heltalsargument, x och y. Funktionen ska returnera ett dubbelt resultat.
4. Använd en if-sats för att kontrollera om värdet på variabelargumentet y är 0. { markerar början på if-kroppen.
5. Meddelandet som ska returneras/kastas om y är 0.
6. Slutet på brödtexten i if-satsen.
7. Funktionen nolldelning ska returnera värdet på x/y.
8. Slutet på kroppen av funktionen zeroDivision.
9. Anropa metoden main(). { markerar början på denna metod.
10. Deklarera en heltalsvariabel och tilldela den värdet 11.
11. Deklarera en heltalsvariabel b och tilldela den värdet 0.
12. Deklarera en dubbelvariabel c och tilldela den värdet 0.
13. Använd try-satsen för att fånga ett undantag. { markerar början av brödtexten i försök/fånga-blocket. Koden som läggs till i kroppen blir den skyddade koden.
14. Anropa funktionen zeroDivision och skicka till argumenten a och b, det vill säga 11 och 0. Resultatet av denna operation kommer att lagras i variabel c.
15. Skriv ut värdet för variabel c på konsolen.
16. Slutet på kroppen av försök/fånga blocket.
17. Fånga undantaget. Det returnerade felmeddelandet kommer att lagras i variabelmeddelandet.
18. Skriv ut det returnerade felmeddelandet på konsolen.
19. Änden av spärrblockets kropp.
20. Programmet bör returnera ett värde vid framgångsrikt genomförande.
21. Slutet på huvuddelen () funktion.

C++ Standardundantag

C++ kommer med en lista över standardundantag som definieras i klass. Dessa beskrivs nedan:

Användardefinierade undantag

Ocuco-landskapet C++ std::exception class tillåter oss att definiera objekt som kan kastas som undantag. Denna klass har definierats i rubrik. Klassen ger oss en virtuell medlemsfunktion som heter vad.

Denna funktion returnerar en noll-terminerad teckensekvens av typen char *. Vi kan skriva över det i härledda klasser för att få en undantagsbeskrivning.

Exempelvis:

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

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Inkludera iostream-huvudfilen i vårt program. Vi kommer att använda dess funktioner utan att få fel.
2. Inkludera undantagshuvudfilen i vårt program. Vi kommer att använda dess funktioner som vad utan fel.
3. Inkludera std-namnutrymmet i vårt program för att använda dess klasser utan att anropa det.
4. Skapa en ny klass med namnet newException. Denna klass ärver undantagsklassen av C++.
5. Början av klasskroppen.
6. Skriv över den virtuella medlemsfunktionen what() som definieras i undantagshuvudfilen. Vi kommer sedan att beskriva vårt eget undantag, det nya undantaget.
7. Starta definitionen av det nya undantaget.
8. Meddelandet som ska returneras om det nya undantaget upptäcks.
9. Slut på definitionen av det nya undantaget.
10. Slutet på texten i klassen newException. Newex är namnet som ska användas för att fånga vårt nya undantag, varefter det nya undantaget kommer att anropas.
11. Anropa main()-funktionen. Programlogiken bör läggas till i dess kropp. { markerar början av dess kropp.
12. Använd en try-sats för att markera koden inom vilken vi måste markera undantaget. { markerar början av brödtexten i försök/fånga-blocket. Koden som omges av detta kommer att skyddas.
13. Kasta newex undantaget om det är fångat.
14. Slutet på provkroppen.
15. Använd catch-satsen för att fånga undantaget. Undantagsfelmeddelandet kommer att lagras i variabel ex.
16. Skriv ut undantagsfelmeddelandet på konsolen.
17. Slutet på meddelandet om fångsten.
18. Programmet bör returnera ett värde om det körs framgångsrikt.
19. Slutet på huvuddelen av funktionen main().

Sammanfattning

• Med undantagshantering i C++, kan du hantera körtidsfel.
• Körtidsfel är de fel som uppstår under programkörning.
• Undantagshantering hjälper dig att hantera eventuella oväntade omständigheter i ditt program.
• När den oväntade omständigheten inträffar överförs programkontrollen till hanterarna.
• För att fånga ett undantag, placerar du en kodsektion under try-catch-blocket.
• Nyckelordet throw hjälper programmet att skapa undantag, vilket hjälper programmet att hantera problemet.
• Nyckelordet try hjälper till att identifiera kodblocket för vilket vissa undantag kommer att aktiveras.
• Vi kan skriva över what()-funktionen i undantagshuvudfilen för att definiera våra undantag.