Institute of Information Science - University of Miskolc

User Tools

Site Tools

Trace: • java_rmi • test • java_socket • lecture_notes • gdd_pelda
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

Next revision		Previous revision
tanszek:oktatas:muszaki_informatika:memoria_kezeles_c-ben [2024/02/13 19:35] – létrehozva kneheztanszek:oktatas:muszaki_informatika:memoria_kezeles_c-ben [2025/03/13 22:13] (current) – [Ellenőrző kérdések] knehez
Line 6: Line 6:
 </sxh> </sxh>
  
-**megoldás**: 80 bájt lefoglalása, majd a pointer nullázása. Probléma: - a lefoglalt 80 byte nem szabadul fel.+**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. 
 + 
 +<sxh c> 
 +m = malloc(80);  
 +// számolás.. egyéb kódok 
 +free(m); 
 +</sxh> 
 + 
 +---- 
 + 
 +Nézzük a következő hibás példát. Mi lehet a hiba?
  
 <sxh c> <sxh c>
Line 13: Line 27:
 </sxh> </sxh>
  
-**megoldás**: felszabadított memóriaterületre akarunk írni.+**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?
  
 <sxh c> <sxh c>
 char *p;  char *p; 
-*p = ’a’;+*p = 'a';
 </sxh> </sxh>
  
-**megoldás**: nem inicializált pointert akarunk használni.+**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.
  
-**2.Feladat:**: Az alábbi 3 függvényből melyik helyes, illetve hibás?+---- 
 + 
 +**Feladat:**: foglaljunk le dinamikusan egy 10 elemű int vektort. 
 + 
 +<sxh c> 
 +#include <stdlib.h> 
 + 
 +int main() { 
 +     
 +    int *v = (int *)malloc(1000 * sizeof(int)); 
 +    free(v); 
 +     
 +    return 0; 
 +} 
 +</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. 
 + 
 +---- 
 + 
 +**Feladat:**: Az alábbi 3 függvényből melyik helyes, illetve hibás?
  
 <sxh c> <sxh c>
-int *f(void)  +int* f(void)  
 {   {  
   int x = 10;     int x = 10;  
Line 31: Line 69:
 }    }   
          
-int *g(void)  +int* g(void)  
 {   {  
   int * p;     int * p;  
Line 38: Line 76:
 }   }  
          
-int *h(void)  +int* h(void)  
 {   {  
   int *p;     int *p;  
-  p = (int *) malloc (sizeof(int));   +  p = (int *) malloc (sizeof(int));    
-  *p = 10;  +
   return p;     return p;  
 }  } 
Line 48: 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 69: Line 111:
 </sxh> </sxh>
  
-**megoldás**: nem ír ki semmit, hanem lefagy. +**megoldás**: nem ír ki semmit, hanem lefagy.
  
-**4.Feladat:**: Hogyan lehetne kijavítani az előző feladatban szereplő programot?+----
  
-**megoldás**: az előző program azért nem működik, mert a pointer nincs inicializálva, ezért a 0-s memóriacímet adja át az f() függvénynek, így a malloc lefoglalja a 4 byte-ot, de hibás helyre írja vissza. A javítás során vegyük figyelembe, hogy egy pointerre mutató pointer már ténylegesen a p változó címét adja vissza, amibe már a f() malloc()-ja már be tudja írni a lefoglalt memória címét.+**Feladat:**: Hogyan lehetne kijavítani az előző feladatban szereplő programot? 
 + 
 +**megoldás**: az előző program azért nem működik, mert a pointer nincs inicializálva (csak egy másolat), ezért a 0-s memóriacímet adja át az f() függvénynek, így a malloc lefoglalja a 4 byte-ot, de hibás helyre írja vissza. A javítás során vegyük figyelembe, hogy egy pointerre mutató pointer már ténylegesen a p változó címét adja vissza, amibe már a f() malloc()-ja már be tudja írni a lefoglalt memória címét.
  
 <sxh c> <sxh c>
Line 92: Line 136:
 </sxh> </sxh>
  
-**5. Feladat:**: Mi a probléma következő programmal?+---- 
 + 
 +**Feladat:**: Mi a probléma következő programmal?
 <sxh c> <sxh c>
 #include<stdio.h>  #include<stdio.h> 
Line 106: 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.1707852903.txt.gz · Last modified: 2024/02/13 19:35 by knehez