C ++ Exception Handling: Încercați, Prindeți, aruncați Exemplu

Ce este gestionarea excepțiilor în C ++?

Gestionarea excepțiilor în C ++ vă oferă o modalitate de gestionare a circumstanțelor neașteptate, cum ar fi erorile de rulare. Deci, ori de câte ori apare o circumstanță neașteptată, controlul programului este transferat la funcții speciale cunoscute sub numele de handlers.

Pentru a prinde excepțiile, plasați o secțiune de cod sub inspecție de excepție. Secțiunea de cod este plasată în blocul try-catch.

Dacă apare o situație excepțională în secțiunea respectivă de cod, se va arunca o excepție. Apoi, gestionarul de excepții va prelua controlul programului.

În cazul în care nu apare nicio circumstanță excepțională, codul se va executa normal. Handlerele vor fi ignorate.

În acest tutorial C ++, veți învăța:

Ce este gestionarea excepțiilor în C ++?
De ce tratarea excepțiilor?
Excepție gestionarea cuvintelor cheie
Sintaxă:
Excepții standard C ++
Excepții definite de utilizator

De ce tratarea excepțiilor?

Iată motivul utilizării Exception Handling în C ++:

Veți separa codul de gestionare a erorilor de codul normal. Codul va fi mai lizibil și mai ușor de întreținut.
Funcțiile pot gestiona excepțiile pe care le aleg. Chiar dacă o funcție aruncă multe excepții, se va ocupa doar de unele. Apelantul se va ocupa de excepțiile neprinse.

Excepție gestionarea cuvintelor cheie

Tratarea excepțiilor în C ++ se învârte în jurul acestor trei cuvinte cheie:

arunca - atunci când un program întâmpină o problemă, aruncă o excepție. Cuvântul cheie aruncare ajută programul să efectueze aruncarea.
catch - un program folosește un handler de excepții pentru a prinde o excepție. Este adăugat la secțiunea unui program în care trebuie să rezolvați problema. Se face folosind cuvântul cheie catch.
try - blocul try identifică blocul de cod pentru care vor fi activate anumite excepții. Ar trebui să fie urmat de unul / mai multe blocuri de captură.

Să presupunem că un bloc de cod va ridica o excepție. Excepția va fi surprinsă printr-o metodă care utilizează cuvinte cheie try and catch. Blocul try / catch ar trebui să înconjoare cod care ar putea genera o excepție. Un astfel de cod este cunoscut sub numele de cod protejat.

Sintaxă:

Încercarea / captarea ia această sintaxă:

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

Deși avem o declarație try, putem avea multe declarații catch.
ExceptionName este numele excepției care trebuie capturată.
Excepția1, excepția2 și excepțiaN sunt numele definite pentru referirea la excepții.

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

Ieșire:

Iată o captură de ecran a codului:

Explicatie cod:

Includeți fișierul antet iostream în program pentru a-i folosi funcțiile.
Includeți fișierul antet vector în program pentru a-i folosi funcțiile.
Includeți spațiul de nume std în program la clasele sale fără a-l apela.
Apelați funcția main (). Logica programului ar trebui adăugată în corpul său.
Creați un vector numit vec pentru a stoca date întregi.
Adăugați elementul 0 la vectorul numit vec.
Adăugați elementul 1 la vectorul numit vec.
Un comentariu. Acesta va fi omis de compilatorul C ++.
Utilizați instrucțiunea try pentru a prinde o excepție. {Marchează începutul corpului blocului try / catch. Codul adăugat în corp va deveni codul protejat.
Încercați să accesați elementul stocat la indexul 2 (al treilea element) al vectorului numit vec. Acest element nu există.
Sfârșitul corpului blocului try / catch.
Prindeți excepția. Mesajul de eroare returnat va fi stocat în variabila ex.
Imprimați un mesaj pe consolă dacă excepția este surprinsă.
Capătul corpului blocului de prindere.
Programul ar trebui să returneze o valoare după executarea cu succes.
Sfârșitul corpului funcției principale ().

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

Ieșire:

Iată o captură de ecran a codului:

Explicatie cod:

Includeți fișierul antet iostream în program pentru a-i folosi funcțiile.
Includeți spațiul de nume std în program la clasele sale fără a-l apela.
Creați o funcție numită zeroDivision care ia două argumente întregi, x și y. Funcția ar trebui să returneze un rezultat dublu.
Folosiți o instrucțiune if pentru a verifica dacă valoarea argumentului variabilă y este 0. {marchează începutul corpului if.
Mesajul care trebuie returnat / aruncat dacă y este 0.
Sfârșitul corpului afirmației if.
Funcția zeroDivision ar trebui să returneze valoarea x / y.
Sfârșitul corpului funcției zeroDivision.
Apelați metoda main (). {Marchează începutul acestei metode.
Declarați o variabilă întreagă și atribuiți-i valoarea 11.
Declarați o variabilă întreagă b și atribuiți-i valoarea 0.
Declarați o variabilă dublă c și atribuiți-i valoarea 0.
Utilizați instrucțiunea try pentru a prinde o excepție. {Marchează începutul corpului blocului try / catch. Codul adăugat în corp va deveni codul protejat.
Apelați funcția zeroDivision și treceți la argumentele a și b, adică 11 și 0. Rezultatul acestei operații va fi stocat în variabila c.
Imprimați valoarea variabilei c pe consolă.
Sfârșitul corpului blocului try / catch.
Prindeți excepția. Mesajul de eroare returnat va fi stocat în mesajul variabil.
Imprimați mesajul de eroare returnat pe consolă.
Capătul corpului blocului de prindere.
Programul ar trebui să returneze o valoare după executarea cu succes.
Sfârșitul corpului funcției principale ().

Excepții standard C ++

C ++ vine cu o listă de excepții standard definite în clasa . Acestea sunt descrise mai jos:

Excepție	Descriere
std :: excepție	Aceasta este o excepție și clasa părinte a tuturor excepțiilor standard C ++.
std :: bad_alloc	Această excepție este aruncată de un nou cuvânt cheie.
std :: bad_cast	Aceasta este o excepție aruncată de dynamic_cast.
std :: bad_exception	Un dispozitiv util pentru gestionarea excepțiilor neașteptate în programele C ++.
std :: bad_typeid	O excepție aruncată de tipid.
std :: logic_error	Această excepție este teoretic detectabilă prin citirea codului.
std :: domain_error	Aceasta este o excepție aruncată după utilizarea unui domeniu matematic nevalid.
std :: argument_invalid	O excepție aruncată pentru utilizarea argumentelor nevalide.
std :: length_error	O excepție aruncată după crearea unui mare std :: string.
std :: out_of_range	Aruncat de către metodă.
std :: runtime_error	Aceasta este o excepție care nu poate fi detectată prin citirea codului.
std :: overflow_error	Această excepție este aruncată după apariția unei revărsări matematice.
std :: range_error	Această excepție este aruncată atunci când încercați să stocați o valoare în afara intervalului.
std :: underflow_error	O excepție aruncată după apariția unei deversări matematice.

Excepții definite de utilizator

Clasa C ++ std :: exception ne permite să definim obiecte care pot fi aruncate ca excepții. Această clasă a fost definită în antetul . Clasa ne oferă o funcție de membru virtual numită what.

Această funcție returnează o secvență de caractere terminată nulă de tip char *. Îl putem suprascrie în clase derivate pentru a avea o descriere a excepției.

Exemplu:

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

Ieșire:

Iată o captură de ecran a codului:

Explicatie cod:

Includeți fișierul antet iostream în programul nostru. Vom folosi funcțiile sale fără a primi erori.
Includeți fișierul antet de excepție în programul nostru. Vom folosi funcțiile sale ca și cum ar fi fără erori.
Includeți spațiul de nume std în programul nostru pentru a utiliza clasele sale fără a-l apela.
Creați o nouă clasă numită newException. Această clasă moștenește clasa de excepție a C ++.
Începutul corpului clasei.
Suprascrieți funcția de membru virtual ce () a definit în fișierul antet de excepție. Vom descrie apoi propria noastră excepție, noua excepție.
Porniți definiția noii excepții.
Mesajul care trebuie returnat dacă noua excepție este prinsă.
Sfârșitul definiției noii excepții.
Sfârșitul corpului clasei newException. Newex este numele care trebuie utilizat pentru a surprinde noua noastră excepție, după care va fi apelată noua excepție.
Apelați funcția main (). Logica programului ar trebui adăugată în corpul său. {Marchează începutul corpului său.
Utilizați o declarație try pentru a marca codul în care trebuie să marcăm excepția. {Marchează începutul corpului blocului try / catch. Codul înconjurat de acesta va deveni protejat.
Aruncați excepția newex dacă este prinsă.
Sfârșitul corpului de încercare.
Utilizați declarația catch pentru a prinde excepția. Mesajul de eroare de excepție va fi stocat în variabila ex.
Imprimați mesajul de eroare de excepție pe consolă.
Declarația sfârșitului corpului capturii.
Programul ar trebui să returneze o valoare dacă se execută cu succes.
Sfârșitul corpului funcției main ().

Rezumat:

Cu gestionarea excepțiilor în C ++, puteți gestiona erorile de runtime.
Erorile de execuție sunt erorile care apar în timpul executării programului.
Gestionarea excepțiilor vă ajută să gestionați orice circumstanțe neașteptate din programul dvs.
Când apare circumstanța neașteptată, controlul programului este transferat către handlers.
Pentru a prinde o excepție, plasați o secțiune de cod sub blocul try-catch.
Cuvântul cheie aruncare ajută programul să arunce excepții, ajutând programul să rezolve problema.
Cuvântul cheie try ajută la identificarea blocului de cod pentru care vor fi activate anumite excepții.
Putem suprascrie funcția what () a fișierului antet de excepție pentru a ne defini excepțiile.