C++ Gestionarea excepțiilor: Încercați, prindeți, aruncați Exemplu

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:

Code Explicaţie:

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:

Iată o captură de ecran a codului:

Code Explicaţie:

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++ vine cu o listă de excepții standard definite în clasă. Acestea sunt descrise mai jos:

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:

Code Explicaţie:

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().

Întrebări frecvente