A program a futása során három jól elkülöníthető szerepű memóriaterülettel rendelkezik, ezek funkciók szerint a globális változók memóriaterületei, a verem és a dinamikusan lefoglalt memóriaterületek.
A memóriakezelés megértése lényegében azon múlik, hogy az ember tisztában van-e vele, a különféle módokon deklarált változók és adatterületek melyik helyre kerülnek. Abból már egyértelműen következnek az órákon általában bemutatott ökölszabályok is, például hogy miért nem lehet lokális változóra mutatót visszaadni egy függvényből.
A globális memóriaterület
A globális memóriaterületen helyezkednek el, ahogyan a neve is mutatja, a globális változók. Ezek a program egész futása
alatt léteznek. Az ott létrehozott változók elhelyezkedése nem változik meg. A kiosztásuk már a program fordításakor eldől, és
még azelőtt létrejönnek, hogy a main() függvény első sorát elkezdené végrehajtani a gép.
1. int a;
2. char s[100] = "hello";
3. char* ptr = "szoveg";
4.
5. int main()
6. {
7. printf("%d", i);
8. }A változók elhelyezését könnyű megérteni, ha betűről betűre ragaszkodunk ahhoz, amit a kódrészlet tartalmaz. A gép úgysem képes másra... Vastag betűvel kiemeltem, hogy melyik sorban mit, milyen típusú változót deklarálunk.
Az 1. sorban egy integert (int) hozunk létre a globális memóriaterületen. A 2. sor egy száz elemű, karakterekből álló tömböt
(char [100]) hoz létre. A tömb első 6 karakterét használjuk (az öt betűs „hello” és a lezáró nulla a sztring végén), a többi
tartalék hely, hogy hosszabb sztringet is másolhassunk ide.
A 3. sor cselesebb. Ott csak egy pointert deklarálunk (char*), amelyik egy, a globális memóriaterületen elhelyezett névtelen
karakter tömbre mutat. Ez nagyon fontos különbség az előzőhöz képest, ahol nem egy pointer és egy tömb jött létre, hanem csak
egy tömb. Itt egy pointer is létrejön, amely igazából független a tömbtől, csak most éppenséggel kezdeti értékként ráállítottuk
arra a tömbre.
A 7. sorban a printf hívás hasonlít ehhez. Megadunk egy formátum sztringet, ami alapján tudja, hogy hogyan kell kiírnia a
változót. Ez a formátum sztring is a globális memóriaterületen helyeződik el, ugyancsak névtelen tömbként. A printf() egy pointert
kap erre futás közben, ahogy a harmadik sor ptr-je is csak egy mutató az előző névtelen tömb elejére.
Ha a printf() után azt mondanánk, hogy ptr=s; akkor onnantól kezdve ptr az s[] tömbre mutat. A „szoveg” sztringet akkor többé
semmi módon nem érjük el, mivel névtelen tömb, és nem tudjuk, hol van a memóriában – nem mutat rá pointerünk.
A verem (stack)
A verembe a függvények lokális változói kerülnek. A verem speciális tulajdonsága, hogy a tartalma fel-le változik; ha egy függvény belsejének végrehajtásába kezdünk, akkor a verem tetején létrejönnek a függvény lokális változói, ha pedig a függvényből visszatérünk, akkor azok a változók megszűnnek. Az adott függvényhíváshoz tartozó memóriaterületet a veremben stack frame-nek nevezzük. A veremben minden függvény csak a saját lokális változóit látja. Ha a függvény saját magát hívja meg, akkor különböző és egymástól független példányok keletkeznek a lokális változóiból.
1. void fv(int b)
2. {
3. char* ptr = "global";
4. char tomb[] = "ding";
5. b = 6;
6. }
7.
8. int main()
9. {
10. int a = 5;
11. char s[50] = "verembe";
12.
13. fv(a);
14. }Ennél a példánál a következő módon alakul a memóriaterületek tartalma. A program indításkor a main() függvényt
kezdi el végrehajtani. A main() függvénynek két lokális változója van, egy integer (int a, 10. sor),
és egy ötven elemű karakter tömb (11. sor). A karakter tömb maga, vagyis az egyes karakterek is a veremben helyezkednek el.
Ha meghívjuk az fv() függvényt (13. sor), akkor az induláskor létrejönnek a veremben a paraméterei (!) és
lokális változói, b nevű egész (1. sor), a ptr nevű pointer (3. sor) és a tomb nevű tömb (4. sor). A ptr-rel megint
csak egy pointert deklarálunk, nem pedig egy tömböt! Ha char*-ot írunk, a gép char*-ot ért alatta. A
verembe, amely a lokális változókat tárolja, így csak a pointer kerül, amely be is állítódik a „global” szót tartalmazó tömbre.
A tömb az előzőekhez hasonlóan a globális memóriaterületre került, és a program egész futása alatt létezik. Az 4. sorban nem
pointert, hanem egy tömböt deklarálunk; annak tartalma is a verembe kerül, még így is, hogy méretét nem adtuk meg, hanem az
inicializáló sztring alapján számolja a fordító. A deklaráció pontos értelmezése mindent eldönt!
A lokális változók csak addig léteznek, amíg a függvény belsejében vagyunk, a 6. sorig bezárólag. Ha visszatérünk a
függvényből, és újra a main()-ben vagyunk, akkor már nem. A b = 6 emiatt értelemszerűen nem a
main() változóját, a-t módosítja, hanem a veremben lévő másolatot.
A kupac (heap)
A dinamikus memóriaterület, vagyis a heap olyan terület, amelyből egy adott nagyságú részt a program futása közben kérhetünk, és ha már nem kell, visszaadhatjuk. Így foglalhatunk le akkora méretű memóriát, amelynek a nagyságát a program írása, fordítása közben még nem ismerjük.
A lefoglaláskor egy pointert, vagyis egy mutatót kapunk arra a memóriahelyre, ahol a gép megfelelő nagyságú területet talált;
amikor arra már nincs szükségünk, akkor felszabadítjuk azt. A terület a lefoglalástól kezdve mienk, egészen addig, amíg vissza
nem adjuk. C-ben ez a malloc() és free() függvényhívásokkal, C++-ban a new és a
delete operátorokkal történik.
A C++ szabvány megkülönbözteti ezt a kettőt. A malloc()-free() páros által
használt memóriaterület neve ott heap, a new-delete operátorok által használt pedig free store.
Ezek persze lehetnek közösek; és egy programban lehet használni egyszerre mind a kettőt. Csak amit a malloc()
foglalt, azt free()-vel kell felszabadítani, nem delete-tel. Ugyanez igaz fordítva is.
A lentebbi példa kód 3. sorban először is deklarálunk egy char* típusú pointert. A pointer maga a veremben jön
létre, és beállítjuk egy dinamikusan lefoglalt memóriaterületre, amely száz karaktert képes tárolni. C-ben ehhez a
malloc() függvényhívást használjuk, C++-ban pedig a new[] operátort. A száz karakternek való hely a dinamikus
memóriaterületen foglalódik le, vagyis a heap-en.
A 4. sorban egy Komplex számra mutató pointert deklarálunk, és foglalunk helyet a heapből egyetlen egy
Komplex számnak. Az 5. sor pedig megint csak egy pointert deklarál csupán a veremben; a pointernek akkor lesz
értelme, ha beállítjuk, hogy valahova mutasson, valami számunkra hasznos helyre. Jelen esetben egy nagy, ezer egész számot
tartalmazó, dinamikusan foglalt tömbre.
A 7. sorban a lefoglalt karakter tömbbe másolunk egy sztringet. A sztring hossza 11 betű, meg van még egy lezáró nullánk, vagyis 12 karakterből áll; 100 karaktert foglaltunk, vagyis ez rendben van. Az eredeti sztring egyébként az előző példákhoz hasonlóan a globális memóriaterületen van, névtelenül. Onnan másolódik át most a heapen lefoglalt területre.
1. int main()
2. {
3. char *tea = malloc(100*sizeof(char));
4. Komplex *k = malloc(sizeof(Komplex));
5. int *sok = malloc(1000*sizeof(int));
6.
7. strcpy(tea, "bai ji guan");
8.
9. free(sok);
10. free(k);
11. free(tea);
12. }1. int main()
2. {
3. char *tea = new char[100];
4. Komplex *k = new Komplex;
5. int *sok = new int[1000];
6.
7. strcpy(tea, "bai ji guan");
8.
9. delete[] sok;
10. delete k;
11. delete[] tea;
12. }A 8. sorban felszabadítjuk a Komplex típusú adatunknak lefoglalt memóriaterületet. Ezt érdemes egyből megtenni,
amikor már nincsen szükség arra a változóra. A k mutató ezután továbbra is oda mutat, ahol az a
Komplex szám volt, de ezután már nem szabad hivatkozni a területre, hiszen visszaadtuk a malloc()-nak
(new-nak), hogy használja újra, ha majd másra kell. Ezt a szabályt mindig, minden körülmények között be kell
tartani; az nem indok, hogy úgysem foglaltunk még új memóriát, vagy hogy „csak már ott van még lécci” az a szám, ahol eredetileg
volt. A programunk lehet többszálú, és akkor egy másik szálban bármikor lefoglalódhat az a terület más célra. Sőt akár az
operációs rendszerhez is visszakerülhetett, és egy másik program használja.
A többi terület felszabadítása ugyanígy történik. Érdemes megfigyelni, hogy C++-ban, amikor csak egyetlen
Komplex-nek foglaltunk helyet, akkor a new operátort használtuk, a felszabadításhoz pedig a
delete-et. A tömb foglalásakor a new[] operátor kellett, és a felszabadításhoz pedig a
delete[]. A kettőt nem szabad keverni; ami new, az később delete; ami new[],
az pedig később delete[]. Nem ugyanazt jelentik a new char és a new char[1]
kifejezések!
Ennek nem csak az az értelme, hogy egy ptr = new Objektum[100] utáni delete
ptr-nél csak az első objektum destruktora hívódik meg. A new és a new[] operátorokat külön
kell átdefiniálni; az egyik lehet, hogy teljesen más helyről ad memóriát, és más nyilvántartást vezet a lefoglalt
területekről, mint a másik.
Erre igazából C-ben és C++-ban is nekünk kell figyelni. A pointeren nem látszik, hogy az egyetlen egy adatra mutat, vagy egy
tömbre. Vagyis egy önálló Komplex szám memóriacíme, és egy Komplex tömb memóriacíme ugyanaz a típus:
Komplex*.
Ugyanígy, egy pointeren nem látszik az, hogy dinamikusan foglaltunk memóriát, és arra mutat a pointer; vagy a pointert beállítottuk egy, a globális memóriaterületen, esetleg a veremben elhelyezkedő változóra (a következő kód 6-8 sora). Csak azt a memóriát kell kézzel felszabadítanunk, amit mi magunk foglaltunk le; a többiről a fordító gondoskodik. A veremből úgyis eltűnik, amikor vége a függvény végrehajtásának; a globális memóriaterületről pedig, amikor a programénak.
1. char global[100];
2.
3. int main()
4. {
5. char tomb[200];
6. char* veremben;
7. char* heapen;
8. char* globalisban;
9.
10. heapen = malloc(100);
11. globalisban = global;
12. veremben = tomb;
13.
14. …
15.
16. free(heapen);
17. }