Mielőtt megtanulná a C dinamikus memória elosztását, értsük meg:
Hogyan működik a memóriakezelés a C-ben?
Amikor egy változót alapadattípussal deklarál, a C fordító automatikusan lefoglalja a változó memóriaterületét a verem nevű memóriakészletben .
Például egy úszó változó általában 4 bájtot vesz igénybe (a platform szerint), amikor deklarálva van. Ezeket az információkat a sizeof operátor segítségével ellenőrizhetjük, az alábbi példában látható módon
#includeint main() { float x; printf("The size of float is %d bytes", sizeof(x)); return 0;}
A kimenet a következő lesz:
The size of float is 4 bytes
Ezenkívül egy meghatározott méretű tömböt egymáshoz kapcsolódó memóriablokkokban osztanak ki, mindegyik blokk mérete egy elemnek felel meg:
#includeint main() { float arr[10];printf("The size of the float array with 10 element is %d", sizeof(arr)); return 0;}
Az eredmény:
The size of the float array with 10 element is 40
Amint azt eddig megtudtuk, az alap adattípus vagy tömb deklarálásakor a memória automatikusan kezelhető. Van azonban egy folyamat a memória C-re történő allokálására, amely lehetővé teszi egy olyan program megvalósítását, amelyben a tömb mérete nem határozható meg, amíg a programot (futásidejű) nem futtatja. Ezt a folyamatot " dinamikus memória-allokációnak " hívják .
Ebben az oktatóanyagban megtanulja-
- Hogyan működik a memóriakezelés a C-ben?
- Dinamikus memóriaallokáció C-ben
- C malloc () Funkció
- A szabad () függvény
- C calloc () Funkció
- calloc () vs. malloc (): Főbb különbségek
- C realloc () Funkció
- Dinamikus tömbök
Dinamikus memóriaallokáció C-ben
A Dinamikus memóriaallokáció a memória manuális allokálása és felszabadítása a programozási igényeknek megfelelően. A dinamikus memóriát olyan mutatókkal kezelik és szolgálják ki, amelyek az újonnan lefoglalt memóriaterületre mutatnak egy olyan területen, amelyet halomnak hívunk.
Most problémamentesen, futás közben dinamikusan létrehozhat és megsemmisíthet egy tömb elemet. Összefoglalva: az automatikus memóriakezelés a verem, a C dinamikus memóriaallokáció pedig a kupacot használja.
Az
| Funkció | Célja |
| malloc () | Kiosztja a kért méretű memóriát, és visszaadja a mutatót a lefoglalt terület első bájtjához. |
| calloc () | Kiosztja a helyet egy tömb elemeinek. Inicializálja az elemeket nullára, és visszaad egy mutatót a memóriába. |
| realloc () | A korábban lefoglalt memória méretének módosítására szolgál. |
| Ingyenes() | Felszabadítja vagy kiüríti a korábban kiosztott memóriaterületet. |
Beszéljük meg a fenti függvényeket alkalmazásukkal
C malloc () Funkció
A C malloc () függvény a memória lefoglalását jelenti. Ez egy olyan funkció, amelyet a memória blokkjának dinamikus lefoglalására használnak. Foglal egy meghatározott méretű memóriaterületet, és visszaadja a memóriahelyre mutató nullmutatót. A visszaadott mutató általában érvénytelen típusú. Ez azt jelenti, hogy a C malloc () függvényt bármely mutatóhoz rendelhetjük.
A malloc () szintaxisa Funkció:
ptr = (cast_type *) malloc (byte_size);
Itt,
- A ptr a cast_type mutató.
- A C malloc () függvény egy mutatót ad vissza a byte_size lefoglalt memóriájába.
Példa malloc () -ra:
Example: ptr = (int *) malloc (50)
Ennek a utasításnak a sikeres végrehajtása esetén 50 bájt memóriaterület van fenntartva. A fenntartott terület első bájtjának címe az int típusú ptr mutatóhoz van hozzárendelve.
Vegyünk egy másik példát:
#includeint main(){int *ptr;ptr = malloc(15 * sizeof(*ptr)); /* a block of 15 integers */if (ptr != NULL) {*(ptr + 5) = 480; /* assign 480 to sixth integer */printf("Value of the 6th integer is %d",*(ptr + 5));}}
Kimenet:
Value of the 6th integer is 480
- Figyelje meg, hogy a sizeof (* ptr) helyett a sizeof (int) helyett a kód robusztusabbá tétele volt, amikor a * ptr deklarációt később más adattípusra írják.
- Az allokáció meghiúsulhat, ha a memória nem elegendő. Ebben az esetben NULL mutatót ad vissza. Tehát a NULL mutató ellenőrzéséhez kódot kell tartalmaznia.
- Ne feledje, hogy a lefoglalt memória összefüggő, és tömbként kezelhető. A zárójelek használata helyett mutatós aritmetikát használhatunk a tömb elemek eléréséhez. Azt javasoljuk, hogy a + gombbal utaljon a tömb elemekre, mert a ++ vagy a + = növekmény használata megváltoztatja a mutató által tárolt címet.
A Malloc () függvény használható a karakter adattípussal, valamint az összetett adattípusokkal, például a struktúrákkal.
A szabad () függvény
A változók memóriája automatikusan lefordításra kerül a fordítás idején. A dinamikus memória-allokáció során kifejezetten el kell osztania a memóriát. Ha nem tette meg, memóriahibából adódhat.
Az free () függvény a memória felszabadítására / elosztására hívja le a C-ben. Ha memóriát szabadít fel a programban, később elérhetőbbé válik.
Például:
#includeint main() {int* ptr = malloc(10 * sizeof(*ptr));if (ptr != NULL){*(ptr + 2) = 50;printf("Value of the 2nd integer is %d",*(ptr + 2));}free(ptr);}
Kimenet
Value of the 2nd integer is 50
C calloc () Funkció
A C calloc () függvény összefüggő allokációt jelent. Ezt a funkciót több memóriablokk lefoglalására használják. Ez egy dinamikus memória-allokációs függvény, amelyet a memória lefoglalására használnak összetett adatstruktúrákhoz, például tömbökhöz és struktúrákhoz.
A Malloc () függvény egyetlen memóriaterület lefoglalására szolgál, míg a C-ben lévő calloc () több memóriaterület lefoglalására szolgál. A calloc () függvény által lefoglalt minden blokk azonos méretű.
A calloc () függvény szintaxisa:
ptr = (cast_type *) calloc (n, size);
- A fenti utasítás n azonos méretű memóriablokk kiosztására szolgál.
- A memóriaterület kiosztása után az összes bájt nullára inicializálódik.
- Visszaadja azt a mutatót, amely jelenleg a lefoglalt memóriaterület első bájtjánál található.
Ha hiba történik a memóriaterület kiosztásakor, például memóriahiány esetén, akkor egy null mutató jelenik meg.
Példa a calloc () -ra:
Az alábbi program kiszámítja egy számtani sorozat összegét.
#includeint main() {int i, * ptr, sum = 0;ptr = calloc(10, sizeof(int));if (ptr == NULL) {printf("Error! memory not allocated.");exit(0);}printf("Building and calculating the sequence sum of the first 10 terms \ n ");for (i = 0; i < 10; ++i) { * (ptr + i) = i;sum += * (ptr + i);}printf("Sum = %d", sum);free(ptr);return 0;}
Eredmény:
Building and calculating the sequence sum of the first 10 termsSum = 45
calloc () vs. malloc (): Főbb különbségek
A következő a legfontosabb különbség a malloc () Vs calloc () között C-ben:
A calloc () függvény általában megfelelőbb és hatékonyabb, mint a malloc () függvény. Míg mindkét funkciót memóriaterület lefoglalására használják, a calloc () egyszerre több blokkot is lefoglalhat. Nem kell minden alkalommal memória blokkot kérnie. A calloc () függvényt olyan komplex adatstruktúrákban használják, amelyek nagyobb memóriaterületet igényelnek.
A calloc () által C-ben lefoglalt memóriablokkot mindig nullára inicializáljuk, míg a malloc () függvényben C-ben mindig szemétértéket tartalmaz.
C realloc () Funkció
A C realloc () függvény segítségével további memóriaméretet adhat a már lefoglalt memóriához. Bővíti az aktuális blokkot, miközben az eredeti tartalmat a jelenlegi állapotában hagyja. A realloc () a C-ben a memória átcsoportosítását jelenti.
A realloc () a korábban lefoglalt memória méretének csökkentésére is használható.
A realloc () szintaxisa Funkció:
ptr = realloc (ptr,newsize);
A fenti utasítás új memóriaterületet rendel hozzá egy meghatározott méretűhez a newsize változóban. A funkció végrehajtása után a mutató visszatér a memóriablokk első bájtjához. Az új méret lehet nagyobb vagy kisebb, mint az előző memória. Nem lehetünk biztosak abban, hogy az újonnan lefoglalt blokk ugyanarra a helyre mutat-e, mint az előző memóriablokk. Ez a funkció átmásolja az összes korábbi adatot az új régióban. Biztosítja, hogy az adatok biztonságban maradjanak.
Példa realloc ():
#includeint main () {char *ptr;ptr = (char *) malloc(10);strcpy(ptr, "Programming");printf(" %s, Address = %u\n", ptr, ptr);ptr = (char *) realloc(ptr, 20); //ptr is reallocated with new sizestrcat(ptr, " In 'C'");printf(" %s, Address = %u\n", ptr, ptr);free(ptr);return 0;}
Amikor a C-ben szereplő realloc () sikertelen műveletet eredményez, nullpontot ad vissza, és a korábbi adatok is felszabadulnak.
Dinamikus tömbök C-ben
A dinamikus tömb C-ben lehetővé teszi az elemek számának szükség szerinti növekedését. A C dinamikus tömböt széles körben használják a számítástechnika algoritmusaiban.
A következő programban létrehoztunk és átméreteztünk egy dinamikus tömböt C-ben
#includeint main() {int * arr_dynamic = NULL;int elements = 2, i;arr_dynamic = calloc(elements, sizeof(int)); //Array with 2 integer blocksfor (i = 0; i < elements; i++) arr_dynamic[i] = i;for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);elements = 4;arr_dynamic = realloc(arr_dynamic, elements * sizeof(int)); //reallocate 4 elementsprintf("After realloc\n");for (i = 2; i < elements; i++) arr_dynamic[i] = i;for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);free(arr_dynamic);}
A C Dynamic tömb program eredménye a képernyőn:
arr_dynamic[0]=0arr_dynamic[1]=1After reallocarr_dynamic[0]=0arr_dynamic[1]=1arr_dynamic[2]=2arr_dynamic[3]=3
Összegzés
- Dinamikusan kezelhetjük a memóriát úgy, hogy szükség szerint memóriablokkokat hozunk létre a kupacban
- A C dinamikus memóriaallokációban a memória futási időben kerül kiosztásra.
- A dinamikus memória-allokáció lehetővé teszi olyan karakterláncok és tömbök manipulálását, amelyek mérete rugalmas és a programban bármikor megváltoztatható.
- Erre akkor van szükség, ha fogalma sincs arról, hogy egy adott szerkezet mennyi memóriát fog elfoglalni.
- A Malloc () a C-ben egy dinamikus memória-allokációs funkció, amely olyan memória-allokációt jelent, amely blokkolja a memóriát a szemétértékre inicializált meghatározott méretű
- A C-ben lévő Calloc () összefüggő memória-allokációs függvény, amely 0 memóriára inicializálva egyszerre több memóriablokkot oszt ki
- A Realloc () C-ben a memória átcsoportosítására szolgál a megadott méretnek megfelelően.
- A Free () függvény segítségével törölhető a dinamikusan lefoglalt memória.