C++ Gestionarea excepțiilor: Încercați, prindeți, aruncați Exemplu
În ce este tratarea excepțiilor C++?
Tratarea excepțiilor în C++ vă oferă o modalitate de a gestiona circumstanțe 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 handlere.
Pentru a detecta excepțiile, plasați o secțiune a codului sub inspecția excepțiilor. Secțiunea de cod este plasată în blocul try-catch.
Dacă apare o situație excepțională în acea secțiune a codului, va fi aruncată o excepție. În continuare, gestionarea excepțiilor va prelua controlul asupra programului.
În cazul în care nu apare nicio circumstanță excepțională, codul se va executa normal. Operatorii vor fi ignorați.
În acest C++ tutorial, vei învăța:
De ce gestionarea excepțiilor?
Iată motivul pentru care utilizați Gestionarea excepțiilor în C++:
- Veți separa codul de tratare 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 generează multe excepții, se va ocupa doar de unele. Apelantul se va ocupa de excepțiile neprinse.
Cuvinte cheie de tratare a excepțiilor
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.
- captură– un program folosește un handler de excepții pentru a captura 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.
- încerca– 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 prinsă printr-o metodă care utilizează cuvinte cheie try and catch. Blocul try/catch ar trebui să înconjoare codul care poate arunca o excepție. Un astfel de cod este cunoscut ca cod protejat.
Sintaxă
try/catch 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 singură declarație try, putem avea multe declarații catch.
- ExceptionName este numele excepției care trebuie prinsă.
- Excepția1, excepția2 și excepțiaN sunt numele dvs. definite pentru referire la excepții.
Exemplu 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; }
ieșire:
Iată o captură de ecran a codului:
Explicația codului:
- Includeți fișierul antet iostream în program pentru a-l folosi funcții.
- Includeți fișierul antet vectorial în program pentru a utiliza funcțiile acestuia.
- Includeți spațiul de nume std în program în 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. Va fi omis de către C++ compilator.
- Utilizați instrucțiunea try pentru a identifica 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 excepția. Mesajul de eroare returnat va fi stocat în variabila ex.
- Tipăriți un mesaj pe consolă dacă excepția este prinsă.
- Capătul corpului blocului de prindere.
- Programul ar trebui să returneze o valoare la executarea cu succes.
- Sfârșitul corpului funcției main().
Exemplu 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; }
ieșire:
Iată o captură de ecran a codului:
Explicația codului:
- Includeți fișierul antet iostream în program pentru a utiliza funcțiile acestuia.
- Includeți spațiul de nume std în program în clasele sale fără a-l apela.
- Creați o funcție numită zeroDivision care preia două argumente întregi, x și y. Funcția ar trebui să returneze un rezultat dublu.
- Utilizaț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 declaraț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 atribuindu-i valoarea 0.
- Declarați o variabilă dublă c și atribuindu-i valoarea 0.
- Utilizați instrucțiunea try pentru a identifica 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.
- Tipăriți valoarea variabilei c pe consolă.
- Sfârșitul corpului blocului try/catch.
- Prinde 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 la executarea cu succes.
- Sfârșitul corpului funcției main().
C++ Excepții standard
C++ vine cu o listă de excepții standard definite în clasă. Acestea sunt descrise mai jos:
Excepție | Descriere |
---|---|
std::excepție | Aceasta este o excepție și clasa părinte a tuturor standardelor C++ excepții. |
std::bad_alloc | Această excepție este generată 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 C++ programe. |
std::bad_typeid | O excepție aruncată de typeid. |
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 invalid din punct de vedere matematic. |
std::argument_invalid | O excepție aruncată pentru utilizarea argumentelor nevalide. |
std::length_error | O excepție aruncată după crearea unui std::string mare. |
std::out_of_range | Aruncat de la metoda. |
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 unui depășire matematică. |
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 unui underflow matematic. |
Excepții definite de utilizator
C++ clasa std::exception ne permite să definim obiecte care pot fi aruncate ca excepții. Această clasă a fost definită în antet. Clasa ne oferă o funcție de membru virtual numită what.
Această funcție returnează o secvență de caractere terminată în nul de tip char *. Îl putem suprascrie în clase derivate pentru a avea o descriere a excepției.
Exemplu:
#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; }
ieșire:
Iată o captură de ecran a codului:
Explicația codului:
- Includeți fișierul antet iostream în programul nostru. Vom folosi funcțiile sale fără a primi erori.
- Includeți fișierul antet excepție în programul nostru. Vom folosi funcțiile sale ca și fără erori.
- Includeți spațiul de nume std în programul nostru pentru a-i folosi clasele 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 membru virtual what() definită în fișierul antet excepție. Vom descrie apoi propria noastră excepție, noua excepție.
- Începeț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 va fi folosit pentru a prinde noua noastră excepție, după care va fi apelată newException.
- Apelați funcția main(). Logica programului ar trebui adăugată în corpul său. { marchează începutul corpului său.
- Utilizați o instrucțiune try pentru a marca codul în care trebuie să marchem excepția. { marchează începutul corpului blocului try/catch. Codul înconjurat de acesta va deveni protejat.
- Aruncă excepția newex dacă este prinsă.
- Sfârșitul corpului de încercare.
- Utilizați instrucțiunea catch pentru a captura excepția. Mesajul de eroare de excepție va fi stocat în variabila ex.
- Tipăriți mesajul de eroare de excepție pe consolă.
- Sfârșitul textului textului de captură.
- Programul ar trebui să returneze o valoare dacă se execută cu succes.
- Sfârșitul corpului funcției main().
Rezumat
- Cu excepție manipularea în C++, puteți gestiona erorile de rulare.
- Erorile de rulare sunt erorile care apar în timpul execuției programului.
- Gestionarea excepțiilor vă ajută să gestionați orice circumstanțe neașteptate în programul dvs.
- Atunci când apare o circumstanță neașteptată, controlul programului este transferat operatorilor.
- Pentru a prinde o excepție, plasați o secțiune de cod sub blocul try-catch.
- Cuvântul cheie throw ajută programul să arunce excepții, ajutând programul să gestioneze 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 excepție pentru a ne defini excepțiile.