Dynamick á alokácia pamäte v C ++

1. Dynamická alokácia pamäte v C++

2. Osnova prednášky • Dynamická alokácia - opakovanie • Alokácia premennej • Alokácia jednorozmerného poľa • Alokácia viacrozmerných polí

3. Smerník Smerník je dátový typ, ktorý uchováva adresu v operačnej pamäti. Na tejto adrese môže byť uložená premenná nejakého typu, prípadne tam môže začínať nejaké pole.

4. Alokácia pamäťového miesta • Statická alokácia: Pamäťové miesto sa alokuje už pri kompilácii a nie je možné meniť jeho veľkosť Je vhodná vtedy, ak vopred presne vieme, koľko pamäte budeme potrebovať • Dynamická alokácia: Pamäťové miesto sa vytvorí počas behu programu Je vhodná vtedy ak: Vopred nevieme, koľko pamäte budeme potrebovať Priestor, ktorý budeme v pamäti potrebovať, je príliš veľký na to, aby sa zmestil do časti vyhradenej pre statické alokácie Umožňuje lepšie sa prispôsobiť požiadavkám programu, resp. užívateľa, znižuje riziko vzniku chýb spôsobených presiahnutím vyhradenej pamäte a zabraňuje zbytočnému plytvaniu pamäťou

5. Alokácia pamäťového miesta • Statická alokácia: Začiatok programu: Priebeh programu: Inštrukcia 1: Inštrukcia 2: ... • Dynamická alokácia: Začiatok programu: Priebeh programu: Inštrukcia 1: Inštrukcia 2: Inštrukcia 3: ...

6. Alokácia a dealokácia premennej • Alokácia sa robí sa pomocou príkazu new typ Ak chceme premennú alokovať s priradením hodnoty: new typ(value) • Dealokácia premennej: delete pointer; • Príklad: Alokácia celočíselnej premennej int *cislo=new int; *cislo=10; cout<<“Na adrese “<<cislo<<“je ulozena hodnota “<<*cislo<<endl; delete cislo; Výstup: Na adrese 00480040 je ulozena hodnota 10

7. Alokácia a dealokácia premennej • Príklad: Alokácia reálneho čísla: float a=2.5, *b=new float(3.2), *c=new float; cout<<“a=“<<a<<“ b=“<<*b<<“ c=“<<*c<<endl; *c=a+*b; cout<<“a=“<<a<<“ b=“<<*b<<“ c=“<<*c<<endl; delete b; delete c; Výstup: a=2.5 b=3.2 c=-4.31260e+008 a=2.5 b=3.2 c=5.7

8. Alokácia a dealokácia premennej • Príklad: Alokácia štruktúry typedef struct { int x,y; } bod; int main() { bod A={100,150}; cout<<"Bod A ma suradnice: "<<A.x<<" "<<A.y<<endl; bod *B=new bod(A); (*B).x+=20; (*B).y-=40; cout<<"Bod B ma suradnice: "<<(*B).x<<" "<<(*B).y<<endl; delete B; return 0; } Výstup: Bod A ma suradnice: 100 150 Bod B ma suradnice: 120 110

9. Alokácia jednorozmerného poľa • Pole s dĺžkou n môžeme alokovať takto: new typ[n] A dealokujeme ho: delete[] array • Príklad: Výpočet hodnôt funkcie f(x)=x2 na intervale <0,1> int n; cout<<"V kolkych bodoch sa ma funkcia vypocitat?"<<endl; cin>>n; float *x=new float[n],*fx=new float[n]; for (int i=0;i<n;i++) { x[i]=i*(1./(n-1)); fx[i]=x[i]*x[i]; cout<<"f("<<x[i]<<")="<<fx[i]<<endl; } delete[] x; delete[] fx;

10. Alokácia jednorozmerného poľa • Výstup: V kolkych bodoch sa ma funkcia vypocitat? 6 f(0)=0 f(0.2)=0.04 f(0.4)=0.16 f(0.6)=0.36 f(0.8)=0.64 f(1)=1

11. *T T T T T T T T T T T T T T T T T T T *T T T T T T T T T T *T T T T T T T T T T *T T T T T T T T T T *T T T T T T T T T T Alokácia dvojrozmerného poľa • Stratégia po riadkoch (pole prvkov typu T): • Princíp: Alokujeme jednorozmerné pole smerníkov na daný typ Pre každý smerník tohto poľa alokujeme jednorozmerné pole prvkov daného typu

12. Alokácia dvojrozmerného poľa • Stratégia po riadkoch – alokácia poľa s rozmermi mn: Alokácia: typ **pole=new typ*[m]; for (i=0; i<m; i++) pole[i]=new typ[n]; Prístup k prvkom: pole[i][j] Dealokácia: for (i=0; i<m; i++) delete[] pole[i]; delete[] pole;

13. Alokácia dvojrozmerného poľa • Stratégia jedného bloku (pole prvkov typu T): • Princíp: Alokujeme naraz celý blok prvkov daného typu potrebný na uchovanie dát Alokujeme jednorozmerné pole smerníkov na daný typ Každý smerník z poľa nasmerujeme tak, aby ukazoval na začiatok príslušného riadku *T T T T T T T T T *T T T T T T T T T *T T T T T T T T T *T T T T T T T T T *T T T T T T T T T

14. T T T T T T T T T T T T T T T T T T T *T *T *T *T *T Alokácia dvojrozmerného poľa • Stratégia jedného bloku: skutočné usporiadanie v pamäti • Alokácia poľa s rozmermi mn: typ *blok=new typ[m*n]; typ **pole=new typ*[m]; for (i=0; i<m; i++) pole[i]=blok+n*i; Prístup k prvkom: pole[i][j] Dealokácia: delete[] pole; delete[] blok;

15. Alokácia dvojrozmerného poľa • Porovnanie uvedených stratégií: 1. Pri stratégii jedného bloku tvorí alokované pole súvislý blok v pamäti, pri stratégii po riadkoch to tak nemusí byť. To je väčšinou výhodou, jediný problém môže nastať, ak už v pamäti nie je voľný súvislý blok s požadovanou veľkosťou 2. Stratégia jedného bloku je rýchlejšia, keďže pri nej len dvakrát voláme new a dvakrát delete[] 3. Stratégia po riadkoch je flexibilnejšia, ak by sme chceli pole, v ktorom by jednotlivé riadky mali premenlivú dĺžku

16. *T T T T T T T T T *T T T T T T T T T *T T T T T T T T T **T *T T T T T T T T T **T *T T T T T T T T T *T T T T T T T T T **T *T T T T T T T T T *T T T T T T T T T *T T T T T T T T T Alokácia trojrozmerného poľa • Stratégia po riadkoch:

17. Alokácia trojrozmerného poľa • Stratégia jedného bloku: **T T T T T *T *T *T *T T T T T T T T T T **T T T T T *T *T *T *T T T T T T T T T *T *T *T *T **T T T T T T T T *T *T *T *T T T T T T **T

18. Alokácia viacrozmerných polí • Ak sú všetky rozmery poľa okrem jedného známe v čase kompilácie, môžeme alokovať viacrozmerné pole nasledujúcim spôsobom: typ (*pole)[const1][const2][const3]... = new typ[d][const1][const2][const3]... Dealokujeme klasickým spôsobom delete[] pole; • Príklad: Alokácia poľa celých čísel s rozmermi 510 intn=5; int (*pole)[10]=new int[n][10]; Nasledujúci zápis nie je dovolený! int n=5; int m=10; int (*pole)[m]=new int[n][m];

19. Memory leak • Ku každej dynamickej alokácii musí byť urobená príslušná dealokácia!! • Predstavme si situáciu, keď máme nejakú funkciu f void f(int n) { char *pole=new int[n]; ... } Čo sa stane, ak vo funkcii f chýba dealokácia? Lokálna premenná pole zanikne, ale v pamäti ostane alokovaných n pamäťových miest, ku ktorým už nie je možný prístup. Takéto miesto v pamäti sa nazýva memory leak a je častou a niekedy ťažko odhaliteľnou programátorskou chybou.

20. Rozdiely medzi alokáciou v C a C++ • V C na alokáciu používame funkciemalloc(..) a free( ), zatiaľ čo v C++ máme operátorynew adelete • Operátor new umožňuje alokovať premennú aj s nastavením jej hodnoty (pri objektoch zavolá koštruktor), malloc to neumožňuje • Operátor delete pri objektoch zavolá ich deštruktor, free nie • V C je možnosť realokovať, teda zmeniť veľkosť vyhradeného pamäťového miesta, v C++ to možné nie je • malloc pri neúspešnej alokácii vráti hodnotu NULL, new oznámi výnimku • Operátory new[] a delete[] umožňujú priamu prácu s poľami, čo malloc a free neumožňujú • new je rýchlejšie ako malloc, ale free je rýchlejšie ako delete. Ale celková kombinácia new/delete je rýchlejšia ako malloc/free.

21. Zhrnutie • Dynamická alokácia je vhodná vtedy, ak vopred nevieme, koľko pamäte budeme potrebovať, alebo ak chceme zabrániť vytváraniu kópií premenných. • Alokácia a dealokácia premenných v C++ sa robí pomocou new a delete, polia sa alokujú pomocou new[] a delete[] • Operátor new umožňuje priamo nastaviť hodnotu premennej • Alokácia viacrozmerných polí sa môže robiť po riadkoch alebo pomocou jedného bloku