1. Programarea calculatoarelor şi limbaje de programare II Capitolul 8
Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei
Programarea calculatoarelor şi limbaje de programare II
Capitolul 8

2. Obiective
Înţelegerea modului în care se pot folosi template-urile de clase pentru crearea grupurilor de tipuri de date
Studierea modului în care se tratează excepţiile care pot apărea la alocarea dinamică a memoriei
Studierea modului în care se poate folosi auto_ptr pentru a preveni problemele de alocare şi dealocare a memoriei

3. Sumar Template-uri de clase
Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei

4. Template-uri de clase Template-uri (şabloanele) de clase
Tipuri parametrizate
se folosesc pentru crearea claselor generice
Pentru adaptarea unei astfel de clase, este nevoie de unul sau mai mulţi parametri de tip care transformă clasa dintr-una generică în una particulară

5. Template-uri de clase Exemplu Stiva (stack)
structură de date care permite stocarea unor valori
ordinea de citire a acestora este inversă ordinii în care au fost înscrise în colecţie
regula last-in-first-out specifică stivelor este valabilă indiferent de tipul elementelor care sunt încărcate
Vom prezenta o implementare generică a unei stive

6. Template-uri de clase T este parametrul de tip al clasei
template <class T>
class Stack {
public:
Stack(int = 10);
~Stack() { delete[] stackPtr; }
bool push(const T&);
bool pop(T&);
private:
int size;
int top;
T* stackPtr;
bool isEmpty() const {return top == -1;}
bool isFull() const {return top == size-1;} };
T este parametrul de tip al clasei

7. Template-uri de clase template<class T>
Stack<T>::Stack(int s) {
size = s > 0 ? s : 10;
top = -1;
stackPtr = new T[size]; }
Alocare dinamică generică pentru tipul de dată T

8. Template-uri de clase template<class T>
bool Stack<T>::push(const T& pushValue) {
if(!isFull())
stackPtr[++top] = pushValue;
return true; }
return false;
Inserează elementul în stivă

9. Template-uri de clase template<class T>
bool Stack<T>::pop(T& popValue) {
if(!isEmpty())
popValue = stackPtr[top--];
return true; }
return false;
Şterge elementul din stivă

10. Template-uri de clase int main() { Stack<double> doubleStack(5);
...
return 0; }
Instanţiază obiectul doubleStack de dimensiune 5
Obiectul doubleStack este de tip Stack<double>

11. Template-uri de clase int main() { ... double f = 1.1;
cout << "Inserarea elementelor in doubleStack\n";
while(doubleStack.push(f))
cout << f << ' ';
f += 1.1; }
cout << "\nStiva este plina. "
<< "Nu se mai poate insera elementul " << f
<< "\n\nExtragerea elementelor din doubleStack\n";
Inserarea elementelor in doubleStack
Stiva este plina. Nu se mai poate insera elementul 6.6

12. Template-uri de clase int main() { ...
cout << "\n\nExtragerea elementelor din doubleStack\n";
while(doubleStack.pop(f))
cout << f << ' ';
cout << "\nStiva este goala. "
<< "Nu se mai pot extrage elemente\n"; }
Extragerea elementelor din doubleStack
Stiva este goala. Nu se mai pot extrage elemente

13. Sumar Template-uri de clase
Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei

14. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei
Vom vedea cum putem trata excepţiile care pot apărea în urma apelului constructorului unei clase atunci când se alocă dinamic memorie
Cum ar trebui, de exemplu, să se comporte constructorul clasei String atunci când apare o eroare la apelul operatorului new prin care se arată că nu este suficient spaţiu în memoria calculatorului pentru păstrarea reprezentării interne a şirului de caractere?

15. Constructorii, destructorii şi tratarea excepţiilor
Varianta 1: returnarea obiectului chiar dacă el nu a fost corect construit, în speranţa că utilizatorul clasei va face testele necesare înainte de a folosi obiectul
Varianta 2: setarea valorii unei variabile din afara constructorului prin a cărei valoare să semnalizăm eroarea care a apărut
Varianta 3: generarea unei excepţii prin care să semnalăm eroarea apărută în constructor

16. Procesarea excepţiilor care apar la apelul operatorului new
C++ standard
atunci cand apare o eroare la apelul lui new, acesta generează o excepţie de tip bad_alloc definită în fişierul header <new>
Compilatoare incompatibile cu C++ standard
operatorul new returnează valoarea 0 în caz de excepţie

17. Procesarea excepţiilor care apar la apelul operatorului new
Exemplu
double *ptr[50];
try {
for(int i = 0; i < 50; i++)
ptr[i] = new double[ ];
cout << "S-au alocat locatii double in ptr["
<< i << "]\n"; }
catch(bad_alloc e)
cout << "A aparut urmatoarea exceptie: "
<< e.what() << endl;
S-au alocat locatii double in ptr[0]
S-au alocat locatii double in ptr[1]
S-au alocat locatii double in ptr[2]
A aparut urmatoarea exceptie: Allocation Failure

18. Procesarea excepţiilor care apar la apelul operatorului new
Este posibilă modificarea metodei standard prin care compilatorul tratează eroarea de nealocare a memoriei
set_new_handler
funcţie definită de C++ standard în header-ul <new>
primeşte ca argument implicit un pointer la o funcţie fără niciun argument şi care returnează void

19. Procesarea excepţiilor care apar la apelul operatorului new
Programatorul poate înregistra această funcţie ca fiind cea care se apelează la apariţia erorii la alocarea memoriei printr-un apel al lui set_new_handler
Odată înregistrată noua funcţie, operatorul new nu va mai genera excepţia bad_alloc, ci va executa corpul noii funcţii

20. Procesarea excepţiilor care apar la apelul operatorului new
using std::set_new_handler;
void customNewHandler() {
cerr << "A fost apelata functia customNewHandler";
abort(); }
int main()
...
set_new_handler(customNewHandler);
S-au alocat locatii double in ptr[0]
S-au alocat locatii double in ptr[1]
S-au alocat locatii double in ptr[2]
A fost apelata functia customNewHandler

21. Clasa auto_ptr şi alocarea dinamică a memoriei
Memory leak
O excepţie care apare după alocarea memoriei şi înainte de apelul operatorului delete pentru dealocarea memoriei poate conduce la imposibilitatea dealocării memoriei până la terminarea execuţiei aplicaţiei
Clasa template auto_ptr
declarată în header-ul <memory>

22. Clasa auto_ptr şi alocarea dinamică a memoriei
Un obiect din clasa auto_ptr menţine un pointer la zona de memorie alocată dinamic
Atunci când un obiect auto_ptr iese din domeniul său de definiţie (scope), se apelează automat operatorul delete pentru pointerul spre care pointează
Pot fi folosiţi operatorii * şi ->
obiectele tip auto_ptr pot fi folosite ca variabilele pointer obişnuite

23. Clasa auto_ptr şi alocarea dinamică a memoriei
...
#include <memory>
using std::auto_ptr;
class Integer {
public:
Integer(int i = 0) : value(i)
{cout << "Constructor pentru Integer: "
<< value << endl;}
~Integer()
{cout << "Destructor pentru Integer: "
void setInteger(int i) {value = i;}
int getInteger() {return value;}
private:
int value; };

24. Clasa auto_ptr şi alocarea dinamică a memoriei
...
int main() {
auto_ptr<Integer> ptrToInteger(new Integer(7));
return 0; }
Se creează obiectul ptrToInteger de tip auto_ptr<Integer>
Obiectul ptrToInteger este iniţializat cu un pointer la un obiect de tip Integer alocat dinamic şi iniţializat cu valoarea 7

25. Clasa auto_ptr şi alocarea dinamică a memoriei
...
int main() {
ptrToInteger->setInteger(99);
cout << "Intregul dupa setInteger: "
<< (*ptrToInteger).getInteger()
<< "\nTerminarea programului" << endl;
return 0; }
Folosirea operatorilor ->, * şi .