calloc()-funksjon i C-bibliotek med programeksempel

Hva er calloc i C?

calloc() i C er en funksjon som brukes til å allokere flere minneblokker av samme størrelse. Det er en dynamisk minneallokeringsfunksjon som allokerer minneplass til komplekse datastrukturer som arrayer og strukturer, og returnerer en tomromspeker til minnet. Calloc står for sammenhengende allokering.

Malloc funksjon brukes til å tildele en enkelt blokk med minneplass mens calloc-funksjonen i C brukes til å tildele flere blokker med minneplass. Hver blokk tildelt av calloc i C-programmering er av samme størrelse.

Hvorfor bruke calloc() i C?

Vanlige variabler og arrayer med fast størrelse låser dimensjonene sine når programmet kompileres, noe som sløser med plass når færre elementer er nødvendig, og feiler fullstendig når flere er nødvendig. calloc() fjerner denne grensen ved å reservere minne under kjøretid, og i motsetning til malloc() tømmer den hver byte til null før blokken leveres tilbake. Dette gjør calloc() til det naturlige valget når et program trenger et rent, forutsigbart minneområde for en array eller struktur hvis størrelse bare er kjent mens koden kjører.

Dynamisk allokering med calloc() passer til flere vanlige situasjoner:

• Numeriske matriser som skal starte på null, for eksempel tellere, histogrammer eller løpende akkumulatorer.
• Datastrukturer der gjenværende søppelverdier ville forårsake subtile, vanskelig åtracog insekter.
• Buffers hvis lengde avhenger av brukerinndata eller en fil som leses mens programmet kjører.
• Blokkene er for store for den begrensede stakken, siden calloc() henter fra den mye større heapen.

Fordi den reserverte blokken er sammenhengende og allerede nullstilt, kan den behandles umiddelbart som en bruksklar array uten en separat initialiseringsløkke.

calloc() syntaks:

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

• Eksemplet ovenfor på calloc i C brukes til å tildele n minneblokker av samme størrelse.
• Etter at minneplassen er tildelt, initialiseres alle byte til null.
• Ocuco pekeren som for øyeblikket er på den første byten av den tildelte minneplassen, returneres.

Når det er en feil ved allokering av minneplass, for eksempel mangel på minne, returneres en null-peker som vist i calloc-eksemplet nedenfor.

Hvordan bruke calloc

Calloc-programmet nedenfor i C beregner summen av 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 av calloc i C-eksempel:

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

Forskjellen mellom calloc() og malloc()

calloc() og malloc() reserverer begge minne på heapen og returnerer begge en void-peker, eller NULL ved feil, men de er forskjellige på tre praktiske måter som avgjør hvilken som skal brukes.

• Initialisering: calloc() setter hver byte i den nye blokken til null, mens malloc() lar innholdet være uinitialisert, slik at en malloc()-blokk inneholder uforutsigbart søppel inntil programmet skriver til den.
• Argumenter: calloc() tar to argumenter, antall elementer og størrelsen på hvert, skrevet calloc(n, størrelse); malloc() tar et enkelt argument, det totale antallet byte, skrevet malloc(n * størrelse).
• Hastighet: malloc() er marginalt raskere fordi den hopper over nullstillingstrinnet, og det er derfor kode som umiddelbart overskriver minnet ofte foretrekker det.

Begge funksjonene deklareres i stdlib.h, og begge frigjør minnet sitt med den samme free()-funksjonen. Velg calloc() når en ren, nullstilt blokk er viktig, og malloc() når rå hastighet er foretrukket og programmet håndterer initialiseringen selv.

Slik frigjør du minne allokert av calloc()

Minne reservert av calloc() ligger på heapen og frigjøres aldri automatisk. Når et program fortsetter å allokere uten å frigjøre, forbruker det sakte alt tilgjengelig minne, en feil kjent som en minnelekkasje. Free()-funksjonen returnerer en ferdig blokk til systemet slik at plassen kan gjenbrukes ved senere allokeringer.

Free()-funksjonen tar et enkelt argument, pekeren som calloc() returnerte, og frigir hele blokken samtidig:

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 reglene for å administrere calloc()-minne på en sikker måte:

• Kall free() nøyaktig én gang for hver vellykkede calloc(); å frigjøre den samme blokken to ganger forårsaker udefinert oppførsel.
• Sett pekeren til NULL etter frigjøring, slik at den ikke kan brukes om igjen som en dinglende peker.
• Aldri frigjør() en peker som calloc() ikke returnerte, inkludert en som er flyttet av pekeraritmetikk.
• Match hver tildeling med en utgivelse før pekeren går utenfor omfanget.

Fordi calloc() og malloc() begge henter fra samme heap, er frigjøringsdisiplinen identisk for begge funksjonene: én free() for hver vellykket allokering, og ingen tilgang til blokken etterpå.ping Balanse mellom allokering og frigjøring er kjernevanen ved manuell minnehåndtering i C, og det forhindrer både lekkasjer og krasj forårsaket av gjenbruk av minne som allerede er returnert.

Spørsmål og svar