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:

Cuvinte cheie de tratare a excepțiilor

Iată o captură de ecran a codului:

Cuvinte cheie de tratare a excepțiilor

Explicația codului:

  1. Includeți fișierul antet iostream în program pentru a-l folosi funcții.
  2. Includeți fișierul antet vectorial în program pentru a utiliza funcțiile acestuia.
  3. Includeți spațiul de nume std în program în clasele sale fără a-l apela.
  4. Apelați funcția main(). Logica programului ar trebui adăugată în corpul său.
  5. Creați un vector numit vec pentru a stoca date întregi.
  6. Adăugați elementul 0 la vectorul numit vec.
  7. Adăugați elementul 1 la vectorul numit vec.
  8. Un comentariu. Va fi omis de către C++ compilator.
  9. 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.
  10. Încercați să accesați elementul stocat la indexul 2 (al treilea element) al vectorului numit vec. Acest element nu există.
  11. Sfârșitul corpului blocului try/catch.
  12. Prinde excepția. Mesajul de eroare returnat va fi stocat în variabila ex.
  13. Tipăriți un mesaj pe consolă dacă excepția este prinsă.
  14. Capătul corpului blocului de prindere.
  15. Programul ar trebui să returneze o valoare la executarea cu succes.
  16. 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:

Cuvinte cheie de tratare a excepțiilor

Iată o captură de ecran a codului:

Cuvinte cheie de tratare a excepțiilor

Explicația codului:

  1. Includeți fișierul antet iostream în program pentru a utiliza funcțiile acestuia.
  2. Includeți spațiul de nume std în program în clasele sale fără a-l apela.
  3. Creați o funcție numită zeroDivision care preia două argumente întregi, x și y. Funcția ar trebui să returneze un rezultat dublu.
  4. Utilizați o instrucțiune if pentru a verifica dacă valoarea argumentului variabilă y este 0. { marchează începutul corpului if.
  5. Mesajul care trebuie returnat/aruncat dacă y este 0.
  6. Sfârșitul corpului declarației if.
  7. Funcția zeroDivision ar trebui să returneze valoarea x/y.
  8. Sfârșitul corpului funcției zeroDivision.
  9. Apelați metoda main(). { marchează începutul acestei metode.
  10. Declarați o variabilă întreagă și atribuiți-i valoarea 11.
  11. Declarați o variabilă întreagă b și atribuindu-i valoarea 0.
  12. Declarați o variabilă dublă c și atribuindu-i valoarea 0.
  13. 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.
  14. 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.
  15. Tipăriți valoarea variabilei c pe consolă.
  16. Sfârșitul corpului blocului try/catch.
  17. Prinde excepția. Mesajul de eroare returnat va fi stocat în mesajul variabil.
  18. Imprimați mesajul de eroare returnat pe consolă.
  19. Capătul corpului blocului de prindere.
  20. Programul ar trebui să returneze o valoare la executarea cu succes.
  21. Sfârșitul corpului funcției main().

C++ Excepții standard

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:

Excepții definite de utilizator

Iată o captură de ecran a codului:

Excepții definite de utilizator

Explicația codului:

  1. Includeți fișierul antet iostream în programul nostru. Vom folosi funcțiile sale fără a primi erori.
  2. Includeți fișierul antet excepție în programul nostru. Vom folosi funcțiile sale ca și fără erori.
  3. Includeți spațiul de nume std în programul nostru pentru a-i folosi clasele fără a-l apela.
  4. Creați o nouă clasă numită newException. Această clasă moștenește clasa de excepție a C++.
  5. Începutul corpului clasei.
  6. Suprascrieți funcția membru virtual what() definită în fișierul antet excepție. Vom descrie apoi propria noastră excepție, noua excepție.
  7. Începeți definiția noii excepții.
  8. Mesajul care trebuie returnat dacă noua excepție este prinsă.
  9. Sfârșitul definiției noii excepții.
  10. 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.
  11. Apelați funcția main(). Logica programului ar trebui adăugată în corpul său. { marchează începutul corpului său.
  12. 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.
  13. Aruncă excepția newex dacă este prinsă.
  14. Sfârșitul corpului de încercare.
  15. Utilizați instrucțiunea catch pentru a captura excepția. Mesajul de eroare de excepție va fi stocat în variabila ex.
  16. Tipăriți mesajul de eroare de excepție pe consolă.
  17. Sfârșitul textului textului de captură.
  18. Programul ar trebui să returneze o valoare dacă se execută cu succes.
  19. 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.