C++ ban mi a különbség a Stack és a Heap memória közt?

Ha egy változónak értéket adsz, az a Stack-re kerül. Ennek elég kicsi a mérete. Annyira, hogy pár ezernél több számot nem is tudsz tárolni rajta.

Ha nagy mennyiségű adatot akarsz tárolni, akkor a heap-et szokás használni. Ez úgy működik, hogy csak pointert tárolsz a stacken, és a pointer mutat a heapre. Mutatok pár példát, hogy megértsd:

int szam=5; //ez egy sima változó, a stacken tárolódik

int *p=&szam; //ez egy pointer, de stacken levő adatra mutat

int *tomb= new int[32]; //ez egy másik pointer, de ez egy olyan tömbre mutat, amit a heap-en tárolunk.

Heapre általában a new operátort használjuk, vagy lehetséges a c nyelvből megmaradt malloc-ot, bár nem szokás annyira.

Fontos, hogy amit heap-en lefoglalsz memóriát, azt kötelességed neked felszabadítani.

new esetén delete (vagy ha tömb, akkor delete[] ), malloc esetén free függvénnyel.

Remélem minden világos így.

A stack-en tárolódik átmenetileg (!) a függvények visszatérési értéke, a statikus foglalású változók értéke valamint a jump-ok visszatérési címe.

A heap dinamikus memóriafoglalásra van, amikor mondjuk megnyitsz egy file-t, aminek előre nem is biztos, hogy ismert a mérete, vagy amikor dinamikus tömböt használsz.

Még annyit az első hsz-hez, hogy a heap-re nem azért kerülnek dolgok, mert a stack ehhez kicsi (ez vicces), hanem azért mert a heap szerepe, működése eredendően más, mint a stack-é.

Az viszont igaz, hogy a heap-ben foglalt memóriát nekünk kell felszabadítanunk (van nyelv, ahol ez automatikus (garbage collector)), a stack viszont ilyesmit nem igényel, mi több, ahhoz hozzá sem szabad nyúlni.

Mind a heap, mind a stack mérete általában paraméterezhető. A stack simán lehet akár a heap többszöröse is, bár ez nem jellemző.

+

A stack (verem) olyan memória, aminek a tetejére lehet pakolni új adatokat, szép sorban. Ez azért jó, mert az egyes függvények amikor meghívódnak, oda teszik pl. a lokális változójukat, ill. a függvényből visszatérés címe és visszatéréskor a visszaadott érték is oda kerül. Amikor ez meghív egy másik függvényt, az rápakolja erre a saját lokális változóit, és amikor visszatér, a verem tetejét lepucolja, és megint a hívó függvény változói lesznek felül. Tipikus LIFO (last in first in) szervezésű memória. Ezt a proginak az a része kezeli, amit a fordító mindig belefordít. (Pl. nyelvtől, fordítótól függhet, hogy a hívó vagy a hívott takarítja-e a stack-et, stb.)

A heap (vagy néhol memory pool, stb.) olyan memória, amit az operációs rendszer kezel, ő tud kiosztani valamennyi helyet, amennyit a futó progi kér. Kb. szabadon foglalható és felszabadítható benne hely, és a kért memóriához egy pointert ad a rendszer. A felszabadítás a memóriát kérő dolga.

** "LIFO (last in first in)"

LIFO (last in first OUT)

:)