C ++ Undantagshantering: Försök, fånga, kasta exempel

Vad är undantagshantering i C ++?

Undantagshantering i C ++ ger dig ett sätt att hantera oväntade omständigheter som körningsfel. Så när en oväntad omständighet inträffar överförs programstyrningen till specialfunktioner som kallas hanterare.

För att fånga undantagen placerar du en del av koden under inspektion av undantag. Kodavsnittet placeras i försöksfångsblocket.

Om en exceptionell situation uppstår inom den delen av koden kommer ett undantag att kastas. Därefter tar undantagshanteraren över kontrollen över programmet.

Om inga exceptionella omständigheter inträffar kommer koden att fungera normalt. Hanterarna kommer att ignoreras.

I denna C ++ -handledning lär du dig:

Vad är undantagshantering i C ++?
Varför undantagshantering?
Nyckelord för undantagshantering
Syntax:
C ++ standardundantag
Användardefinierade undantag

Varför undantagshantering?

Här är anledningen till att använda Exception Handling i C ++:

Du kommer att skilja din felhanteringskod från din normala 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 vissa. Den som ringer kommer att hantera de ofångna undantagen.

Nyckelord för undantagshantering

Undantagshantering i C ++ kretsar kring dessa tre nyckelord:

throw - när ett program stöter på ett problem ger det ett undantag. Kasta nyckelordet hjälper programmet att utföra kastet.
fånga - 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 hjälp av nyckelordet fånga.
försök - försöksblocket identifierar kodblocket för vilket vissa undantag kommer att aktiveras. Det bör följas av ett / flera fångstblock.

Antag att ett kodblock ger ett undantag. Undantaget kommer att fångas av en metod som använder sökord för att fånga. Försök / fångst-blocket ska omge koden 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öksuttalande kan vi ha många fångstuttalanden.
ExceptionName är namnet på undantaget som ska fångas.
Exception1, exception2 och exceptionN är dina definierade namn för att hänvisa till undantagen.

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

Produktion:

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

Kodförklaring:

Inkludera iostream-rubrikfilen i programmet för att använda dess funktioner.
Inkludera vektorhuvudfilen i programmet för att använda dess funktioner.
Inkludera std-namnområdet i programmet till dess klasser utan att kalla det.
Ring huvudfunktionen (). Programmets logik bör läggas till i sin kropp.
Skapa en vektor med namnet vec för att lagra heltaldata.
Lägg till elementet 0 i vektorn med namnet vec.
Lägg till element 1 i vektorn med namnet vec.
En kommentar. Den hoppas över av C ++ - kompilatorn.
Använd försöksuttrycket för att få ett undantag. {Markerar början på kroppen för try / catch block. Koden som läggs till i kroppen kommer att bli den skyddade koden.
Försök att komma åt elementet som lagras i index 2 (tredje element) i vektorn som heter vec. Detta element finns inte.
Slutet på kroppen för försök / fångstblock.
Fånga undantaget. Det returnerade felmeddelandet lagras i variabeln ex.
Skriv ut ett meddelande på konsolen om undantaget fångas.
Slutet på fångblocket.
Programmet ska returnera ett värde efter framgångsrik körning.
Slutet på huvudfunktionen ().

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

Produktion:

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

Kodförklaring:

Inkludera iostream-rubrikfilen i programmet för att använda dess funktioner.
Inkludera std-namnområdet i programmet till dess klasser utan att kalla det.
Skapa en funktion med namnet zeroDivision som tar två heltalargument, x och y. Funktionen ska returnera ett dubbelt resultat.
Använd en if-sats för att kontrollera om värdet för variabelargumentet y är 0. {markerar början på if-kroppen.
Meddelandet som ska returneras / kastas om y är 0.
Slutet på kroppen om if-uttalandet.
ZeroDivision-funktionen ska returnera värdet på x / y.
Slutet på zeroDivision-funktionen.
Ring huvudmetoden (). {Markerar början på denna metod.
Förklara en heltalsvariabel och tilldela den värdet 11.
Förklara en heltalsvariabel b och tilldela den värdet 0.
Förklara en dubbel variabel c och tilldela den värdet 0.
Använd försöksuttrycket för att få ett undantag. {Markerar början på kroppen för try / catch block. Koden som läggs till i kroppen kommer att bli den skyddade koden.
Anropa zeroDivision-funktionen och vidarebefordra till argument a och b, det vill säga 11 och 0. Resultatet av denna operation kommer att lagras i variabel c.
Skriv ut värdet på variabel c på konsolen.
Slutet på kroppen för försök / fångstblock.
Fånga undantaget. Det returnerade felmeddelandet lagras i det variabla meddelandet.
Skriv ut det returnerade felmeddelandet på konsolen.
Slutet på fångblocket.
Programmet ska returnera ett värde efter framgångsrik körning.
Slutet på huvudfunktionen ().

C ++ standardundantag

C ++ kommer med en lista över standardundantag definierade i -klassen. Dessa beskrivs nedan:

Undantag	Beskrivning
std :: undantag	Detta är ett undantag och föräldraklassen för alla standard C ++ - undantag.
std :: bad_alloc	Detta undantag kommer från ett nytt nyckelord.
std :: bad_cast	Detta är ett undantag som dynamiskt kastas.
std :: bad_exception	En användbar enhet för hantering av oväntade undantag i C ++ - program.
std :: bad_typeid	Ett undantag från typid.
std :: logic_error	Detta undantag kan teoretiskt detekteras genom att läsa kod.
std :: domain_error	Detta är ett undantag som kastas efter användning av en matematiskt ogiltig domän.
std :: ogiltigt_argument	Ett undantag för att använda ogiltiga argument.
std :: längdfel	Ett undantag efter att du skapat en stor std :: -sträng.
std :: out_of_range	Kastas med metoden.
std :: runtime_error	Detta är ett undantag som inte kan detekteras genom att läsa koden.
std :: overflow_error	Detta undantag kastas efter att ett matematiskt överflöd har inträffat.
std :: range_error	Detta undantag kastas när du försöker lagra ett värde utanför området.
std :: underflow_error	Ett undantag kastat efter matematisk underflöde.

Användardefinierade undantag

C ++ std :: exception-klassen tillåter oss att definiera objekt som kan kastas som undantag. Denna klass har definierats i rubriken . Klassen ger oss en virtuell medlemsfunktion som heter what.

Denna funktion returnerar en null-avslutad karaktärsekvens av typen char *. Vi kan skriva över det i härledda klasser för att få en undantagsbeskrivning.

Exempel:

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

Produktion:

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

Kodförklaring:

Inkludera iostream-rubrikfilen i vårt program. Vi kommer att använda dess funktioner utan att få fel.
Inkludera undantagshuvudfilen i vårt program. Vi kommer att använda dess funktioner som vad utan fel.
Inkludera std-namnområdet i vårt program för att använda sina klasser utan att kalla det.
Skapa en ny klass med namnet newException. Denna klass ärver undantagsklassen C ++.
Början på klassens kropp.
Skriv över den virtuella medlemsfunktionen vad () som definierades i undantagshuvudfilen. Vi kommer då att beskriva vårt eget undantag, det nya undantaget.
Starta definitionen av det nya undantaget.
Meddelandet som ska returneras om det nya undantaget fångas.
Slutet på definitionen av det nya undantaget.
Slutet på kroppen av klass newException. Newex är namnet som ska användas för att fånga vårt nya undantag, varefter newException kommer att kallas.
Ring huvudfunktionen (). Programmets logik bör läggas till i sin kropp. {Markerar början på sin kropp.
Använd ett försöksuttalande för att markera koden inom vilken vi behöver markera undantaget. {Markerar början på kroppen för try / catch block. Koden som omges av detta skyddas.
Kasta newex-undantaget om det fångas.
Slut på försökskroppen.
Använd fångstdeklarationen för att fånga undantaget. Undantagsfelmeddelandet lagras i variabel ex.
Skriv ut undantagsfelmeddelandet på konsolen.
Slutet på fångstuttrycket.
Programmet ska returnera ett värde om det körs framgångsrikt.
Slutet på huvudfunktionens () kropp.

Sammanfattning:

Med undantagshantering i C ++ kan du hantera runtime-fel.
Runtime-fel är de fel som uppstår under programkörningen.
Undantagshantering hjälper dig att hantera alla oväntade omständigheter i ditt program.
När den oväntade omständigheten inträffar överförs programkontrollen till hanterare.
För att få ett undantag placerar du en kodsektion under försöksfångsblocket.
Kasta nyckelordet hjälper programmet att kasta undantag, vilket hjälper programmet att hantera problemet.
Try-nyckelordet hjälper till att identifiera kodblocket för vilket vissa undantag kommer att aktiveras.
Vi kan skriva över vad () -funktionen i undantagshuvudfilen för att definiera våra undantag.