Institute of Information Science - University of Miskolc

User Tools

Site Tools

Trace: • gdd_pelda • java_rmi • java_http_server • java_socket • http_protokol • lecturenotes • strukturak_c-ben • matrixok_kezelese • lecture_notes • cascading_style_sheets
tanszek:oktatas:muszaki_informatika:memoria_kezeles_c-ben

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
tanszek:oktatas:muszaki_informatika:memoria_kezeles_c-ben [2025/03/12 18:59] – kneheztanszek:oktatas:muszaki_informatika:memoria_kezeles_c-ben [2025/03/13 22:13] (current) – [Ellenőrző kérdések] knehez
Line 7: Line 7:
  
 **megoldás**: 80 bájt lefoglalása, majd a pointer nullázása. Probléma: - a lefoglalt 80 byte nem szabadul fel. ''m = NULL'' sor természetesen nullázza az ''m'' mutatót, de ettől még a 80 bájt lefoglalva marad. **megoldás**: 80 bájt lefoglalása, majd a pointer nullázása. Probléma: - a lefoglalt 80 byte nem szabadul fel. ''m = NULL'' sor természetesen nullázza az ''m'' mutatót, de ettől még a 80 bájt lefoglalva marad.
 +
 +----
  
 Egy pointerhez memória lefoglalása majd amikor már nincs rá szükség, akkor a felszabadítása az alábbi váz alapján valósítható meg. Egy pointerhez memória lefoglalása majd amikor már nincs rá szükség, akkor a felszabadítása az alábbi váz alapján valósítható meg.
Line 15: Line 17:
 free(m); free(m);
 </sxh> </sxh>
 +
 +----
  
 Nézzük a következő hibás példát. Mi lehet a hiba? Nézzük a következő hibás példát. Mi lehet a hiba?
Line 24: Line 28:
  
 **megoldás**: felszabadított memóriaterületre akarunk írni. Ha már meghívtuk a free() memória felszabadító függvényt, akkor nem lehet tovább használni a pointert. (ameddig a malloc()-al újra foglalunk neki memóriát.) **megoldás**: felszabadított memóriaterületre akarunk írni. Ha már meghívtuk a free() memória felszabadító függvényt, akkor nem lehet tovább használni a pointert. (ameddig a malloc()-al újra foglalunk neki memóriát.)
 +
 +----
  
 A következő példában nem használunk dinamikus memóriafoglalást, ami elvileg még jó is lehet, de mégsem szabályos. Miért? A következő példában nem használunk dinamikus memóriafoglalást, ami elvileg még jó is lehet, de mégsem szabályos. Miért?
Line 33: Line 39:
  
 **megoldás**: nem inicializált pointert akarunk használni. Azaz a ''char *p'', nem ad értéket a ''p'' pointernek, csak helyet foglal neki, és azon a helyen 0 van, vagy valami memóriaszemét. Ha a következő sorban a '' *p = 'a' ''-val a p által mutatott címre bele szeretnénk másolni a 'a'-t akkor az nem lesz lehetséges, mert a 0-ás címre nem írhatunk. **megoldás**: nem inicializált pointert akarunk használni. Azaz a ''char *p'', nem ad értéket a ''p'' pointernek, csak helyet foglal neki, és azon a helyen 0 van, vagy valami memóriaszemét. Ha a következő sorban a '' *p = 'a' ''-val a p által mutatott címre bele szeretnénk másolni a 'a'-t akkor az nem lesz lehetséges, mert a 0-ás címre nem írhatunk.
 +
 +----
  
 **Feladat:**: foglaljunk le dinamikusan egy 10 elemű int vektort. **Feladat:**: foglaljunk le dinamikusan egy 10 elemű int vektort.
Line 48: Line 56:
 </sxh>  </sxh> 
  
-A kód igazából nem csinál túl sok használhatót, csak demonstrálja a malloc() használatát. A paramétere azt jelenti hogy hány bájtot szeretnénk lefoglalni. Önmagában 1000-el meghívva csak 250 darab int értéknek foglal helyet, mert minden ''int'' 4 byte-ot foglal. Mivel ezt nem akarjuk fejből tudni ezért használjuk a beépített sizeof() operátort, ami sizeof(int) esetén 4-et ad vissza. Összefoglalva az 1000 int lefoglalásához 4000 byte-ok kell lefoglalni.+A kód igazából nem csinál túl sok használhatót, csak demonstrálja a malloc() használatát. A paramétere azt jelenti, hogy hány bájtot szeretnénk lefoglalni. Önmagában 1000-el meghívva csak 250 darab int értéknek foglal helyet, mert minden ''int'' 4 byte-ot foglal. Mivel ezt nem akarjuk fejből tudni ezért használjuk a beépített sizeof() operátort, ami sizeof(int) esetén 4-et ad vissza. Összefoglalva az 1000 int lefoglalásához 4000 byte-ok kell lefoglalni.
  
 +----
  
 **Feladat:**: Az alábbi 3 függvényből melyik helyes, illetve hibás? **Feladat:**: Az alábbi 3 függvényből melyik helyes, illetve hibás?
Line 76: Line 85:
  
 **megoldás**: csak a h() függvény helyes. A f() és g() hibásak, mert ezekben az esetekben a memóriacím a veremben jön létre és a visszaadott érték helytelen memóriacímre fog mutatni. **megoldás**: csak a h() függvény helyes. A f() és g() hibásak, mert ezekben az esetekben a memóriacím a veremben jön létre és a visszaadott érték helytelen memóriacímre fog mutatni.
 +Az f() és g() esetén lokális változókat hozunk létre, és ezekre mutató memóriacímet adunk vissza. A függvény használatakor, a használat után ezek a memóriacímek nem használhatók tovább. 
 +A h() esetén is a p változó lokális lesz, az is megszűnik a függvény használata után, de a malloc() által visszaadott memória cím (mint számérték továbbra is használható) a ''return p'' itt is nem a p-t, hanem a p-ben tárolt címet adja vissza, ami a h() esetén továbbra is használható.
  
 +//A példa azt mutatja, hogy a malloc() által létrehozott cím és a mögötte lefoglalt memória globális, nem számít hol hívtuk meg.//
  
-**3.Feladat:**: Mi lesz az alábbi program kimenete?+---- 
 + 
 +**Feladat:**: Mi lesz az alábbi program kimenete?
  
 <sxh c> <sxh c>
Line 97: Line 111:
 </sxh> </sxh>
  
-**megoldás**: nem ír ki semmit, hanem lefagy. +**megoldás**: nem ír ki semmit, hanem lefagy. 
 + 
 +----
  
 **Feladat:**: Hogyan lehetne kijavítani az előző feladatban szereplő programot? **Feladat:**: Hogyan lehetne kijavítani az előző feladatban szereplő programot?
Line 119: Line 135:
 } }
 </sxh> </sxh>
 +
 +----
  
 **Feladat:**: Mi a probléma következő programmal? **Feladat:**: Mi a probléma következő programmal?
Line 134: Line 152:
 </sxh> </sxh>
  
-**megoldás**: a p NULL-ázása után, a free() nem tudja, hogy hol van az a memóriacím, amit fel kell szabadítani. A free() nem a p változót, hanem az abban tárolt címet szabadítja fel.+**megoldás**: a p NULL-ázása után, a free() nem tudja, hogy hol van az a memóriacím, amit fel kell szabadítani, a free() igazából nem egy változót magát, hanem a benne tárolt memória címet (mint számértékhez tartozó foglalást) szünteti meg.) Más szóval: a free() nem a p változót, hanem az abban tárolt címet szabadítja fel.
  
 +===== Ellenőrző kérdések =====
 +
 +**Mi a helyes deklarációja egy int típusra mutató pointernek?**
 +  
 +  A) int p*;
 +  B) int *p;
 +  C) pointer int p;
 +  D) int &p;
 +
 +Megoldás: B
 +
 +----
 +
 +**Hogyan lehet helyesen lefoglalni memóriát egy 10 elemű int tömbnek dinamikusan?**
 +
 +  A) int *arr = malloc(10);
 +  B) int arr = malloc(10 * sizeof(int));
 +  C) int *arr = malloc(10 * sizeof(int));
 +  D) int arr[10] = malloc(sizeof(int));
 +
 +Helyes válasz: C
 +
 +----
 +**Mi lesz az eredmény?**
 +
 +<sxh c>
 +int array[] = {100, 200, 300};
 +int *ptr = array;
 +printf("%d", *(ptr++));
 +printf("%d", *ptr);
 +</sxh>
 +
 +  A) 100200
 +  B) 200300
 +  C) 100100
 +  D) 200200
 +
 +Megoldás: A. *(ptr++) előbb kiírja a 100-at, majd eggyel tovább lépteti a pointert. A következő kiírás már a 200-ra mutat.
 +
 +----
 +**Melyik állítás igaz az alábbiak közül?**
 +
 +  A) Egy pointer típusa nem függ attól, hogy milyen adatra mutat.
 +  B) Egy pointer mindig egész számot tárol.
 +  C) Pointerek aritmetikája nem megengedett C-ben.
 +  D) Egy pointer típusa meghatározza, hogy milyen típusú adatot érhetünk el rajta keresztül.
 +
 +Helyes válasz: D
 +
 +----
 +**Mi lesz az eredmény?**
 +
 +<sxh c>
 +int x = 5, y = 10;
 +int *p = &x;
 +int *q = &y;
 +*p = *q;
 +printf("%d %d", x, y);
 +</sxh>
 +
 +  A) 5 10
 +  B) 10 10
 +  C) 5 5
 +  D) 10 5
 +
 +Helyes válasz: B. 
 +
 +----
 +**Mire mutat a p pointer a következő deklaráció után?**
 +
 +<sxh c>
 +int arr[10];
 +int *p = arr;
 +</sxh>
 +
 +  A) Az arr tömb első elemére
 +  B) Az arr tömb utolsó elemére
 +  C) Az arr tömb méretére
 +  D) Véletlenszerű memória címre
 +
 +Megoldás: A
 +
 +----
 +**Mi a hiba a következő kódrészletben?**
 +
 +<sxh c>
 +int num = 20;
 +int *ptr;
 +*ptr = num;
 +</sxh>
 +
 +  A) Érvénytelen pointer-dereferencia (nem inicializált pointer)
 +  B) Szintaktikai hiba
 +  C) Hiányzó pontosvessző
 +  D) A num változó helytelen típusa
 +
 +Megoldás: A
 +
 +----
 +**Mi lesz a következő kód kimenete?**
 +
 +<sxh c>
 +char *str = "Hello";
 +printf("%c", *(str+1));
 +</sxh>
 +
 +  A) H
 +  B) e
 +  C) l
 +  D) o
 +
 +Megoldás: B
 +
 +----
 +**Mit jelent, ha egy pointer NULL értékű?**
 +
 +  A) A pointer érvényes memória címre mutat
 +  B) A pointer egy egész számot tárol
 +  C) A pointer nem mutat érvényes memória címre
 +  D) A pointer konstans értékre mutat
 +
 +Megoldás: C
 +
 +----
 +**Mi lesz a következő kód kimenete?**
 +
 +<sxh c>
 +int a[] = {2, 4, 6, 8};
 +int *p = a;
 +printf("%d", *(p + 2));
 +</sxh>
 +
 +  A) 2
 +  B) 4
 +  C) 6
 +  D) 8
 +
 +Megoldás: C
 +
 +----
 +**Melyik operátor adja vissza egy változó memória-címét?**
 +
 +  A) *
 +  B) &
 +  C) %
 +  D) #
 +
 +Megoldás: B
 +
 +----
 +**Mit ír ki a következő programrészlet?**
 +
 +<sxh c>
 +int x = 5;
 +int *p = &x;
 +*p = 10;
 +printf("%d", x);
 +</sxh>
  
 +  A) 5
 +  B) 0
 +  C) 10
 +  D) véletlenszerű érték
  
 +Megoldás: C , mivel az x értéke megváltozik a pointeren keresztül
tanszek/oktatas/muszaki_informatika/memoria_kezeles_c-ben.1741805984.txt.gz · Last modified: 2025/03/12 18:59 by knehez