Lab 12 – Tratarea erorilor - excepţii

Cuprins
1. Excepții .................................................................................................................................................. 1
2. Excepții standard................................................................................................................................... 2
3. Excepții netratate .................................................................................................................................. 3
4. Excepții în funcții membre .................................................................................................................... 4
5. Definirea propriilor excepții .................................................................................................................. 5
6. Exerciții.................................................................................................................................................. 6

1. Excepții

Excepţiile reprezintă un mecanism de tratare a erorilor care apar în timpul execuției unui
program. O excepție C++ este răspunsul la o situație excepțională care apare în timp ce un program
rulează, de exemplu împărțirea la 0.

#include <iostream>

using namespace std;

int imp(int x, int y)

{
return (x / y);
}

int main() {
cout << imp(4, 0);
return 0;
}

La rularea codului de mai sus apare următoarea eroare:

 Pentru lucrul cu excepții, C++ definește trei cuvinte cheie:

throw – utilizat pentru lansarea (aruncarea) excepțiilor;

try – folosit pentru a defini un bloc de instrucțiuni care lansează/pot lansa excepții;

catch – utilizat pentru a defini un bloc de instrucțiuni pentru tratarea excepțiilor care
apar în blocul try.

#include <iostream>

using namespace std;

int imp(int x, int y)

{
if (y == 0)
{
throw "Impartire la 0";
}

return (x / y);
}

int main() {
try
{
cout << imp(4, 2) << endl;
cout << imp(4, 0) << endl;
cout << imp(6, 2) << endl;
}
catch (const char* err)
{
cout << err << endl;
}

return 0;
}
Ieșire:
2
Impartire la 0

2. Excepții standard

Biblioteca C++ standard furnizează o clasă de bază pentru tratarea obiectelor furnizate ca
excepţii, std::exception, precum și o serie de clase care o extind pe aceasta și care definesc excepții
pentru tratarea anumitor erori. Lista excepțiilor din biblioteca standard C++ poate fi consultată accesând
http://en.cppreference.com/w/cpp/error/exception.
Clasa std::exception conține o metodă virtuală, what(), ce returnează un char* (un mesaj care
descrie eroarea produsă). În exemplul următor este utilizată std::out_of_range pentru tratarea erorii
care apare atunci când se încearcă accesarea unui element dintr-un vector, aflat pe o poziție mai mare
decât dimensiunea acestuia minus 1.
#include <iostream>
#include <vector>
using namespace std;

int main() {
vector<int> a(3, 0);
try
{
cout << a.at(3) << endl;
}
catch(out_of_range &e)
{
cout << e.what() << endl;
}
return 0;
}

3. Excepții netratate

Funcţiile pot lansa excepţii care pot să nu aibă nici o modalitate de tratare a lor. Pentru a
preveni aceste situaţii, se poate introduce un handler catch-all:

#include <iostream>
using namespace std;

int imp(int x, int y) {

if (y == 0)
{
throw "Impartire la 0";
}
return (x / y);
}

int main() {
try
{
cout << imp(4, 2) << endl;
cout << imp(4, 0) << endl;
cout << imp(6, 2) << endl;
}
catch (int e)
{
cout << "Eroare: " << e << endl;
}
catch (...)
{
cout << "Eroare necunoscuta" << endl;
}

return 0;
}
 4. Excepții în funcții membre

Se folosesc:
 În special în constructori pentru a semnala unele erori la crearea obiectelor;
 Când se doreşte semnalarea unei erori fără a duce la terminarea programului.

#include <iostream>

class A
{
public:
A()
{
throw "Exceptie in construcorul clasei A!";
}
};

int main()
{
try
{
A a;
}
catch(const char* e)
{
std::cout << e << std::endl;;
}

return 0;
}
 5. Definirea propriilor excepții

Putem defini propriile excepții prin extinderea clasei std::exception.

#include <iostream>
#include <exception>
using namespace std;

class MyException : public exception

{
public:
const char* what()
{
return "Impartire la 0";
}
};

int imp(int x, int y)

{
if (y == 0)
{
throw MyException();
}

return (x / y);
}

int main()
{
try
{
cout << imp(4, 0);
}
catch(MyException &e)
{
cout << e.what() << endl;
}

return 0;
}
 6. Exerciții

1. Implmentați exemplele din laborator. Testați și alte (minim 3) excepții din biblioteca standard.
2. Fie clasa Student declarată astfel:

class Student
{
std::string m_sNume;
int m_iNotaP2;

public:
Student(std::string nume, int notaP2);
void Afisare();
};
 Adăugați definițiile pentru metodele clasei Student;
 În constructorul de inițializare verificați dacă notaP2 se află în itervalul [1, 10]. În caz contrar,
aruncați o excepție proprie.
 Testați metodele implementate folosind următorul cod pentru funcția main:

int main()
{
Student s1("Jeff Bezos", 12);
Student s2("Bill Gates", -5);
Student s3("Steve Jobs", 9);

return 0;
}

 Adăugați logica necesară pentru tratarea excepțiilor.