malloc() függvény a C könyvtárban az EXAMPLE-vel

Mi a malloc C-ben?

A malloc() függvény a memóriafoglalást jelenti. Ez egy memóriablokk dinamikus lefoglalására szolgáló funkció. Lefoglalja a megadott méretű memóriaterületet, és visszaadja a memóriahelyre mutató nullmutatót. A visszaadott mutató általában void típusú. Ez azt jelenti, hogy bármely mutatóhoz hozzárendelhetünk malloc függvényt.

Szintaxis

ptr = (cast_type *) malloc (byte_size);

Itt,

• A ptr egy cast_type mutató.
• A malloc függvény egy mutatót ad vissza a byte_size lefoglalt memóriájába.

Example: ptr = (int *) malloc (50)

Ha ez az utasítás sikeresen végrehajtódik, 50 bájtos memóriaterület kerül lefoglalásra. A lefoglalt 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 a malloc megvalósítására:

#include <stdlib.h>
int 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));
    }
}

output:

Value of the 6th integer is 480

Figyeljük meg, hogy a sizeof(*ptr) függvényt használtuk a sizeof(int) helyett, hogy a kód robusztusabb legyen, amikor a *ptr deklarációt később más adattípusra tipizáljuk.

A kiosztás sikertelen lehet, 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 megadnia.

Ne feledjük, hogy a lefoglalt memória összefüggő, és tömbként kezelhető. Használhatjuk mutató aritmetikai utasításokat kell használni a tömb elemeinek eléréséhez a szögletes zárójelek [] használata helyett. Javasoljuk, hogy a tömb elemeire + jelet hivatkozzunk, mert a ++ vagy += növelés megváltoztatja a mutató által tárolt címet.

A Malloc függvény karakteres adattípusokkal, valamint összetett adattípusokkal, például struktúrákkal is használható.

Miért érdemes a malloc() függvényt használni C-ben?

A statikus tömbök és a közönséges változók méretét a program fordítása során rögzítik, ami helyet pazarol, ha a követelmény kisebbnek bizonyul, és teljesen meghiúsul, ha nagyobbnak bizonyul. A malloc() ezt úgy oldja meg, hogy futásidőben kér memóriát, így a program a puffer méretét pontosan a fogadott adatmennyiséghez igazíthatja. Ez a futásidejű rugalmasság a lényege. dinamikus memóriafoglalás C-ben.

A malloc()-tal történő dinamikus allokáció számos gyakori helyzetben a helyes választás:

• A bemenet mennyisége ismeretlen, amíg a program le nem fut, például egy fájl vagy egy felhasználó által megadott lista beolvasása közben.
• Nagy blokkokra van szükség, amelyek túlcsordulnának a korlátozott veremből, mivel a malloc() a sokkal nagyobb halomból merít adatokat.
• Az adatoknak túl kell élniük az azokat létrehozó függvényt, mivel a heap memória mindaddig megmarad, amíg explicit módon fel nem szabadítják őket.
• A struktúráknak és tömböknek növekedniük vagy zsugorodniuk kell a program végrehajtása közben.

Mivel a lefoglalt blokk mutatóként kerül visszaadásra, olcsón átadható függvények között az alapul szolgáló adatok másolása nélkül.

Hogyan szabadítsunk fel memóriát a malloc() segítségével?

A malloc() által lefoglalt memória a heap-en található, és soha nem szabadul fel automatikusan. Amikor egy program folyamatosan foglal le memóriát felszabadítás nélkül, lassan felhasználja az összes elérhető memóriát, ezt a hibát memóriaszivárgásnak nevezik. A free() függvény egy kész blokkot ad vissza a rendszernek, így a szabad terület újra felhasználható.

A free() függvény egyetlen argumentumot fogad el, a malloc() által visszaadott mutatót, és egyszerre felszabadítja az egész blokkot:

int *ptr;
ptr = malloc(10 * sizeof(int));
if (ptr != NULL) {
    /* use the allocated memory here */
    free(ptr);   /* release the block */
    ptr = NULL;  /* avoid a dangling pointer */
}

A dinamikus memória biztonságos kezeléséhez kövesse az alábbi szabályokat:

• A free() függvényt minden sikeres malloc() függvénynél pontosan egyszer hívjuk meg; ugyanazon blokk kétszeri felszabadítása definiálatlan viselkedést okoz.
• Felszabadítás után állítsd a mutatót NULL-ra, hogy ne lehessen újra felhasználni lógó mutatóként.
• Soha ne free() függvényként használja a malloc() függvényt olyan mutatóra, amelyet nem adott vissza, beleértve a mutatóaritmetika által eltolt mutatót is.
• Minden allokációhoz párosítson egy megfelelő kiadást, mielőtt a mutató kilépne a hatóköréből.

Egyik semping A C nyelven a manuális memóriakezelés központi eleme az egyensúlyban lévő lefoglalás és felszabadítás, amely megakadályozza a felszabadult memória újrafelhasználásából eredő szivárgásokat és összeomlásokat.

malloc() vs. calloc(): Főbb különbségek

malloc() és calloc() Mindkettő halom memóriát foglal le, de argumentumaikban és az új blokk kezelésében különböznek. A malloc() egyetlen argumentumot fogad el, a bájtok teljes számát, és a tartalmat inicializálatlanul hagyja, így a blokk kiszámíthatatlan szemétértékeket tárol, amíg a program nem ír bele. A calloc() két argumentumot fogad el, az elemek számát és méretét, és minden bájtot nullára töröl, mielőtt visszaadja a mutatót.

A gyakorlati különbségek három pontra vezethetők vissza:

• Inicializálás: a calloc() nullázza a memóriát, míg a malloc() nem, ami a malloc()-ot valamivel gyorsabbá teszi, ha az értékek egyébként is felülíródnának.
• Argumentumok: malloc(n * size) utasítást írsz, de a calloc(n, size) utasítással ugyanazt a tömböt foglalod le.
• Használati eset: válaszd a calloc()-ot, ha a tiszta, nullázott blokk fontos, és a malloc()-ot, ha a sebesség az előnyben részesített, és az inicializálást manuálisan kell kezelni.

Mindkét függvény az stdlib.h fájlban deklarálható, mindkettő void pointert vagy NULL értéket ad vissza hiba esetén, és mindkettő ugyanazzal a free() függvénnyel adja vissza a memóriáját.

GYIK