template-uri de clase. tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei
DESCRIPTION
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. Obiective. Înţelegerea modului în care se pot folosi template-urile de clase pentru crearea grupurilor de tipuri de date - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/1.jpg)
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
![Page 2: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/2.jpg)
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
![Page 3: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/3.jpg)
Sumar
Template-uri de clase Tratarea excepţiilor care pot apărea la
alocarea dinamică a memoriei
![Page 4: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/4.jpg)
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ă
![Page 5: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/5.jpg)
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
![Page 6: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/6.jpg)
Template-uri de clase
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
![Page 7: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/7.jpg)
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
![Page 8: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/8.jpg)
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ă
![Page 9: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/9.jpg)
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ă
![Page 10: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/10.jpg)
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>
![Page 11: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/11.jpg)
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 doubleStack1.1 2.2 3.3 4.4 5.5 Stiva este plina. Nu se mai poate insera elementul 6.6
![Page 12: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/12.jpg)
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
5.5 4.4 3.3 2.2 1.1 Stiva este goala. Nu se mai pot extrage elemente
![Page 13: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/13.jpg)
Sumar
Template-uri de clase Tratarea excepţiilor care pot apărea la
alocarea dinamică a memoriei
![Page 14: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/14.jpg)
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?
![Page 15: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/15.jpg)
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
![Page 16: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/16.jpg)
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
![Page 17: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/17.jpg)
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[50000000]; cout << "S-au alocat 50000000 locatii double in ptr[" << i << "]\n"; } } catch(bad_alloc e) { cout << "A aparut urmatoarea exceptie: " << e.what() << endl; }
S-au alocat 50000000 locatii double in ptr[0]S-au alocat 50000000 locatii double in ptr[1]S-au alocat 50000000 locatii double in ptr[2]
A aparut urmatoarea exceptie: Allocation Failure
![Page 18: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/18.jpg)
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
![Page 19: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/19.jpg)
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
![Page 20: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/20.jpg)
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 50000000 locatii double in ptr[0]S-au alocat 50000000 locatii double in ptr[1]S-au alocat 50000000 locatii double in ptr[2]A fost apelata functia customNewHandler
![Page 21: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/21.jpg)
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>
![Page 22: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/22.jpg)
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
![Page 23: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/23.jpg)
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: " << value << endl;} void setInteger(int i) {value = i;} int getInteger() {return value;}private: int value;};...
![Page 24: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/24.jpg)
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
![Page 25: Template-uri de clase. Tratarea excepţiilor care pot apărea la alocarea dinamică a memoriei](https://reader031.vdocuments.mx/reader031/viewer/2022020106/5681379d550346895d9f40c7/html5/thumbnails/25.jpg)
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 .