Informatika2-2015/Eloadas 12 C-5 Memoria kezeles

Memória kezelés

A programozási nyelveknek alapvetően két fajta hozzáállása lehet a memória kezeléséhez, automatikus vagy manuális. A ma is elterjedt programozási nyelvek közül csak a C és a C++ az ami még manuális memóriakezelést használ. A mai előadáson megnézzük hogy ez pontosan mit jelent. Ez azért is tanulságos lesz, hogy jobban megértsük hogy működnek azok a nyelvek amik automatikus memória kezelést használnak.

Mit is értünk memória kezelés alatt

Először nézzünk egy python példát:

# Ez egy lista objektum:
lista1 = [1, 2, 3]
# Ez az objektum valahol letezik a memoriaban,
# es a "lista1" valtozo hivatkozik ra.
 
# Ha ezt csinalom akkor mar ket valtozo hivatkozik ra:
lista2 = lista1
 
# Ha ezt, akkor megint csak egy:
lista1 = []
 
# Ha ezt csinalom akkor mar egy valtozo sem hivatkozik ra:
lista2 = []
# Akkor vajon letezik meg az a lista?
# Elerni mar nem tudom egyik valtozon keresztul se.

A válasz a kód végén feltett kérdésre az, hogy nem tudjuk. Mivel nem elérhető az a lista sehogyan sem, ezért a program helyes futása szempontjából mindegy hogy még létezik-e az a lista, hiszen már soha nem tudjuk használni semmire. Azonban abból a szempontból fontos hogy létezik-e, hogy ha még létezik, akkor a memóriának az a része ahol ez a lista található, nem használható másra.

Mivel a python egy olyan nyelv, ami automatikus memóriakezelést tartalmaz, ezért ott a felhasználónak nem kell törődnie ezzel a problémával, a python interpreter biztosít minket hogy minden amire már nincs szükség az idővel megsemmisül, és a soha nem fog a program túl sok fölösleges memóriát használni. Majd az előadás későbbi részében visszatérünk rá, hogy ezt pontosan hogyan csinálja.

Azonban a példa mutatja, hogy a program számára a memória is egy erőforrás, amit kezelni kell. Amikor létrehozok egy objektumot vagy bármilyen változót, akkor annak lefoglalok/allokálok valamennyi memóriát. Ezt a részt a memóriában fel kell szabadítani mielőtt lefoglalhatom valamilyen más célra.

C memóriakezelés

C verem

A C memóriakezelésének egy részével már találkoztunk. Amikor két előadással ezelőtt arról beszéltem, hogy mi egy változó élettartalma, akkor az egyfajta memóriakezelés. Mindig amikor elkezdődik egy blokk a kódban, akkor a C program lefoglalja a szükséges memóriát az abban levő változóknak, és amikor vége a blokknak, akkor felszabadítja ezt a memóriát.

Mivel a blokkok szigorúan tartalmazzák egymást (nem lehet részleges átfedés két blokk között), ezért ha egy blokk éppen fut amig egy másik blokk kezdődik, akkor a másik blokknak lesz előbb vége. Ez azt jelenti, hogy ha lefoglaltam már az éppen futó X blokkhoz X memóriát, és most lefoglalok Y blokkhoz Y memóriát, akkor biztos az Y-t kell előbb felszabadítanom mint az X-et.

Emiatt ezeket a memóriablokkokat tárolhatom egymás "tetején", az X tetejére tehetem az Y-t, hisz az Y-t biztos előbb kell eldobnom mint az X-et. A memóriának azt a részét, ahol a C program a blokkok memóriáját így, egymás tetején, tárolja, úgy hívják hogy verem (angolul stack).

Itt látható egy ábra az angol wikipédiáról, hogy hogy néz ki ez a verem. Itt a DrawSquare függvény meghívta a DrawLine függvényt, és amíg a DrawLine függvény fut, addig a DrawLine függvény paraméterei és belső (lokális) változói le vannak tárolva a verem tetején. Mivel a DrawSquare biztosan nem tud véget érni amig a DrawLine még fut, ezért nem baj hogy lejjebb van a veremben és még nem felszabadítható.

Ahhoz hogy ez így megtehető legyen, ahhoz az is kell egyébként, hogy a C-ben minden típusnak fix a mérete. Ezért le tudok foglalni egy memóriablokkot a DrawSquare-nek, a tetejére tehetek egy másik memóriablokkot, és nem kell aggódnom amiatt, hogy hirtelen nagyobb hely fog kelleni valamelyik változónak a DrawSquare-ben. (Ezért van, hogy a tömbök is fix méretűek ellenben a python-os listával ellentétben, és ilyen kevés fajta típus van.)