calloc() függvény a C Library-ben a PÉLDA programmal

Mi a calloc C-ben?

A C nyelvben használt calloc() függvény több, azonos méretű memóriablokk lefoglalására szolgál. Ez egy dinamikus memóriaelosztási függvény, amely a memóriaterületet összetett adatstruktúrákhoz, például tömbökhöz és struktúrákhoz osztja ki, és egy void pointert ad vissza a memóriára. A Calloc a contiguous allocation (folytonos allocation) rövidítése.

Malloc függvény Egyetlen memóriablokk lefoglalására szolgál, míg a C-ban a calloc függvény több memóriablokk lefoglalására szolgál. A C programozásban a calloc által lefoglalt minden blokk azonos méretű.

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

A közönséges változók és a fix méretű tömbök a program fordítása során rögzítik a dimenzióikat, ami helyet pazarol, ha kevesebb elemre van szükség, és teljesen meghibásodik, ha több elemre van szükség. A calloc() ezt a korlátot úgy oldja fel, hogy futásidőben memóriát foglal le, és a malloc()-tal ellentétben minden bájtot nullára ürít, mielőtt visszaadja a blokkot. Ez teszi a calloc()-ot természetes választássá, amikor egy programnak tiszta, kiszámítható memóriaterületre van szüksége egy tömb vagy struktúra számára, amelynek mérete csak a kód futása közben ismert.

A calloc() függvény segítségével történő dinamikus allokáció számos gyakori helyzethez illeszkedik:

• Numerikus tömbök, amelyeknek nullával kell kezdődniük, például számlálók, hisztogramok vagy futó akkumulátorok.
• Az olyan adatszerkezetek, ahol a visszamaradt szemétértékek finom, nehezen kezelhető problémákat okoznának.tracés bogarak.
• Buffers, amelyek hossza a felhasználói beviteltől vagy a program futása közben beolvasott fájltól függ.
• A blokkok túl nagyok a korlátozott veremhez, mivel a calloc() a sokkal nagyobb halomból merít.

Mivel a lefoglalt blokk összefüggő és már nullázott, azonnal kezelhető használatra kész tömbként, külön inicializálási ciklus nélkül.

calloc() szintaxis:

ptr = (cast_type *) calloc (n, size);

• A calloc fenti utasítás példája C-ben n azonos méretű memóriablokk lefoglalására szolgál.
• A memóriaterület lefoglalása után az összes bájt nullára inicializálódik.
• Az mutató amely jelenleg a lefoglalt memóriaterület első bájtjánál van, visszaküldésre kerül.

Ha hiba történik a memóriaterület lefoglalásakor, például memóriahiány, akkor nulla mutatót ad vissza, amint az az alábbi calloc példában látható.

Hogyan kell használni a calloc-ot

Az alábbi calloc program C-ben kiszámítja egy számtani sorozat összegét.

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

A calloc eredménye a C példában:

 
Building and calculating the sequence sum of the first 10 terms
Sum = 45

Különbség a calloc() és a malloc() között

A calloc() és a malloc() egyaránt memóriát foglal le a heap-en, és mindkettő void pointert, vagyis hiba esetén NULL-t ad vissza, mégis három gyakorlati szempontból különböznek, amelyek eldöntik, melyiket használják.

• Inicializálás: a calloc() függvény minden bájtot nullára állít az új blokkban, míg a malloc() függvény a tartalmat inicializálatlanul hagyja, így a malloc() blokk kiszámíthatatlan szemetet tárol, amíg a program nem ír bele.
• Argumentumok: a calloc() két argumentumot fogad el, az elemek számát és mindegyik méretét, írva: calloc(n, size); a malloc() egyetlen argumentumot fogad el, a bájtok teljes számát, írva: malloc(n * size).
• Sebesség: a malloc() valamivel gyorsabb, mivel kihagyja a nullázási lépést, ezért a memóriát azonnal felülíró kód gyakran ezt a függvényt részesíti előnyben.

Mindkét függvény az stdlib.h fájlban van deklarálva, és mindkettő ugyanazzal a free() függvénnyel szabadítja fel a memóriáját. A calloc() függvényt akkor válaszd, ha a tiszta, nullázott blokk fontos, a malloc() függvényt pedig akkor, ha a nyers sebesség a célszerűbb, és a program maga kezeli az inicializálást.

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

A calloc() által lefoglalt memória a heap-en található, és soha nem szabadul fel automatikusan. Amikor egy program folyamatosan foglal le anélkül, hogy felszabadítana, 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 későbbi lefoglalásokhoz újra felhasználható.

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

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

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

• A free() függvényt minden sikeres calloc() 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ényt alkalmazzon olyan mutatóra, amelyet a calloc() nem adott vissza, beleértve a mutatóaritmetika által eltolt mutatót is.
• Minden allokációhoz párosítson egy felszabadulást, mielőtt a mutató kilépne a hatóköréből.

Mivel a calloc() és a malloc() is ugyanabból a heapből merít adatokat, a felszabadítási eljárás mindkét függvény esetében azonos: minden sikeres lefoglalásért egy free() függvény indul el, és utána nincs hozzáférés a blokkhoz. Keepping A C nyelven a manuális memóriakezelés alapvető szokása az egyensúlyban lévő lefoglalás és felszabadítás, és ez megakadályozza mind a szivárgásokat, mind a már visszaadott memória újrafelhasználásából eredő összeomlásokat.

GYIK