Programozási feladatban a bekért adatokat a dinamikus memóriába kell menteni, ez mit jelent?

A program három eltérő 'fajta' memóriát használ:

- statikus

- stack

- dinamikus (heap)

A statikus tárterület, ahogy a neve sugallja, a statikus (globális) változóknak van fenntartva, amelyek a program teljes futása alatt elérhetőek.

Amikor létrehozol egy sima változót, az a stack-re kerül, a részletekbe most nem mennék bele, de ez egy könnyen hozzáférhető, limitált méretű memóriaterület, alkalmas arra, hogy a különböző lokális változókat benne tárold, de nagy méretű, vagy változó méretű változókat célszerűen nem itt tárolunk.

És itt jön képbe a dinamikus tárterület, avagy a heap. Ez egy lényegesen nagyobb méretű memóriaterület, amelynek az elérése nem annyira evidens, mint a stack-nek. Célszerűen ide pakoljuk a változó méretű, illetve nagyméretű adatokat. A csavar, hogy míg a stack esetében csak létrehozod a változót, és kész vagy, valahogy így:

int num = 5;

A heap esetében manuálisan kell helyet foglalni az adatnak, és létre kell hozni egy mutatót (pointer), amelyen keresztül eléred majd:

int* num = new int(5);

Ami ilyenkor történik, hogy a heap-en lefoglalsz memóriát egy integer értéknek, illetve a stack-re felveszel egy pointer változót (num), amely az előzővel szemben nem magát az int értéket tárolja, hanem a memóriacímet, amelyen megtalálható ez az int érték. tehát ha kiíratnád a num változó értékét, akkor valami random memóriacímet kapnál, és nem azt, hogy 5. Ahhoz, hogy elérd a mögötted értéket, dereferálni kell a pointer változót:

cout<<num<<endl; //kiíratja a memóriacímet, nem az érétket

cout<<*num<<endl; //kiíratja a mutatott értéket, ami 5.

És itt jön még egy csavar. AZ előbb láthattad, hogyan tudsz a dinamikus memóriába felvenni egy int változót (aminek nincs sok értelme), de hogyan tudsz egy int tömböt felvenni, monjduk 5 eleműt? Elég hasonló módon:

int* num_arr = new int[5];

Ezesetben lefoglalsz egy 5 elemű int tömbnek helyet a heap-ben, és a stack-en felveszel egy pointer változót, ami a tömb elejére mutat. Itt érdemes megjegyezni, hogy a tömb változók valójában a tömb elejére mutató pointerek, tehát amikor létrehozol egy ilyet:

int num_arr[5];

Akkor lényegében egy ugyanolyan pointer változót kapsz a tömb elejére, mintha dinamikusan hoznád létre. Ergo, pontosan ugyanúgy kell kezelni. Ez azt jelenti, hogy a dinamikusan létrehozott tömb esetében nem kell dereferálni (*num_arr) a pointert, ugyanúgy sima indexeléssel éred el a tömböd elemeit.

Ha már itt tartunk, említsük meg, hogy létezik ilyen is:

int** num_arr;

Ez egy int pointerre mutató int pointer. Tehát tárolsz a stack-en egy változót, ami egy heap-en levő címre mutat, amelynek az értéke eg ymásik heap-en levő címre mutat, ahol eg yint érték található. Ezzel meg lehet cisnálni a következőt:

int** num_arr = int*[5];

Ezesetben lesz a heap-en egy 5 elemű tömböd, amelyekben nem int értékek lesznek, hanem int értékre mutató pointerek. ezek a pointerek pedig igazából mutathatnak int tömbökre is, és voila, van egy tömböd, amelynek minden eleme egy tömbre mutat. Van egy kétdimanziós tömböd. Ugyanígy csinálhatsz 3, 4, akárhány mélységű dinamikus tömböt.

Amire még nagyon oda kell figyelni amikor dinamikus memóriával dolgozol: Mint mondtam, neked kell manuálisan lefoglalni a memóriaterületet az értékeknek (erre szolgál a new kulcsszó), éppezért a program elvárja, hogy a memória felszabadítását is te magad végezd. Erre használatos a delete kulcsszó.

int* num = new int(5);

//...

delete num;

Ha tömböt tárolsz a pointer mögött:

int* num_arr = new int[5];

/...

delete[] num;

Javaslom, hogy ahányszor megírsz egy 'new' utasítást, rögtön írd meg hozzá a 'delete' utasítást is, hogy ne felejtődjön el, és ne legyen memóriaszivárgás a programodban.