calloc() Funktion i C-bibliotek med programeksempel

Hvad er calloc i C?

calloc() i C er en funktion, der bruges til at allokere flere hukommelsesblokke af samme størrelse. Det er en dynamisk hukommelsesallokeringsfunktion, der allokerer hukommelsesplads til komplekse datastrukturer såsom arrays og strukturer og returnerer en void-pointer til hukommelsen. Calloc står for contiguous allocation (sammenhængende allokering).

Malloc funktion bruges til at allokere en enkelt blok hukommelsesplads, mens calloc-funktionen i C bruges til at allokere flere hukommelsesblokke. Hver blok, der er allokeret af calloc'en i C-programmering, er af samme størrelse.

Hvorfor bruge calloc() i C?

Almindelige variabler og arrays med fast størrelse låser deres dimensioner, når programmet kompileres, hvilket spilder plads, når der er behov for færre elementer, og fejler fuldstændigt, når der er behov for flere. calloc() fjerner denne begrænsning ved at reservere hukommelse under kørsel, og i modsætning til malloc() nulstiller den hver byte, før blokken returneres. Dette gør calloc() til det naturlige valg, når et program har brug for et rent, forudsigeligt hukommelsesområde til et array eller en struktur, hvis størrelse kun er kendt, mens koden kører.

Dynamisk allokering med calloc() passer til flere almindelige situationer:

• Numeriske arrays, der skal starte ved nul, såsom tællere, histogrammer eller løbende akkumulatorer.
• Datastrukturer hvor resterende affaldsværdier ville forårsage subtile, vanskelige attracog insekter.
• Buffers hvis længde afhænger af brugerinput eller en fil, der læses, mens programmet kører.
• Blokkene er for store til den begrænsede stak, da calloc() trækker fra den meget større heap.

Fordi den reserverede blok er sammenhængende og allerede nulstillet, kan den straks behandles som et brugsklart array uden en separat initialiseringsløkke.

calloc() Syntaks:

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

• Ovenstående sætningseksempel på calloc i C bruges til at allokere n hukommelsesblokke af samme størrelse.
• Efter at hukommelsespladsen er allokeret, initialiseres alle bytes til nul.
• pointer som i øjeblikket er ved den første byte af den tildelte hukommelsesplads, returneres.

Når der er en fejl ved tildeling af hukommelsesplads, såsom mangel på hukommelse, returneres en nul-pointer som vist i nedenstående calloc-eksempel.

Sådan bruger du calloc

Nedenstående calloc-program i C beregner summen af ​​en aritmetisk sekvens.

#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;
    }

Resultat af calloc i C eksempel:

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

Forskellen mellem calloc() og malloc()

calloc() og malloc() reserverer begge hukommelse på heapen og returnerer begge en void-pointer, eller NULL, ved fejl, men de adskiller sig på tre praktiske måder, der afgør, hvilken en der skal bruges.

• Initialisering: calloc() sætter hver byte i den nye blok til nul, mens malloc() lader indholdet være uinitialiseret, så en malloc()-blok indeholder uforudsigeligt affald, indtil programmet skriver til den.
• Argumenter: calloc() tager to argumenter, antallet af elementer og størrelsen af ​​hvert, skrevet calloc(n, size); malloc() tager et enkelt argument, det samlede antal bytes, skrevet malloc(n * size).
• Hastighed: malloc() er marginalt hurtigere, fordi den springer nulstillingstrinnet over, hvilket er grunden til, at kode, der øjeblikkeligt overskriver hukommelsen, ofte foretrækker den.

Begge funktioner erklæres i stdlib.h, og begge frigiver deres hukommelse med den samme free()-funktion. Vælg calloc(), når en ren, nulstillet blok er vigtig, og malloc(), når rå hastighed foretrækkes, og programmet håndterer initialiseringen selv.

Sådan frigør du hukommelse allokeret af calloc()

Hukommelse reserveret af calloc() ligger på heapen og frigives aldrig automatisk. Når et program bliver ved med at allokere uden at frigøre, forbruger det langsomt al tilgængelig hukommelse, en defekt kendt som en hukommelseslækage. Funktionen free() returnerer en færdig blok til systemet, så pladsen kan genbruges ved senere allokeringer.

Funktionen free() tager et enkelt argument, pointeren som calloc() returnerede, og frigiver hele blokken på én gang:

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 */
}

Følg disse regler for at administrere calloc()-hukommelse sikkert:

• Kald free() præcis én gang for hver vellykket calloc(); to gange frigivelse af den samme blok forårsager udefineret adfærd.
• Sæt markøren til NULL efter frigørelse, så den ikke kan genbruges som en dinglende markør.
• Frigør aldrig () en pointer, som calloc() ikke returnerede, inklusive en, der er flyttet af pointer-aritmetik.
• Match hver allokering med en udgivelse, før markøren går uden for rækkevidde.

Fordi calloc() og malloc() begge trækker fra den samme heap, er frigørelsesdisciplinen identisk for begge funktioner: én free() for hver vellykket allokering, og ingen adgang til blokken bagefter.ping Allokering og frigivelse i balance er den centrale vane ved manuel hukommelsesstyring i C, og det forhindrer både lækager og nedbrud forårsaget af genbrug af hukommelse, der allerede er returneret.

Ofte Stillede Spørgsmål