calloc() Functie in C-bibliotheek met programma VOORBEELD

Wat is calloc in C?

De functie `calloc()` in C wordt gebruikt om meerdere geheugenblokken van dezelfde grootte toe te wijzen. Het is een dynamische geheugentoewijzingsfunctie die geheugenruimte toewijst aan complexe datastructuren zoals arrays en structuren, en een lege pointer naar het geheugen retourneert. `calloc` staat voor aaneengesloten toewijzing.

Malloc-functie wordt gebruikt om een ​​enkel blok geheugenruimte toe te wijzen, terwijl de calloc-functie in C wordt gebruikt om meerdere blokken geheugenruimte toe te wijzen. Elk blok dat door de calloc wordt toegewezen in C-programmering heeft dezelfde grootte.

Waarom calloc() gebruiken in C?

Gewone variabelen en arrays met een vaste grootte vergrendelen hun afmetingen tijdens het compileren van het programma. Dit leidt tot verspilling van geheugen wanneer er minder elementen nodig zijn en mislukt volledig wanneer er meer nodig zijn. De functie `calloc()` heft deze beperking op door geheugen te reserveren tijdens de uitvoering en, in tegenstelling tot `malloc()`, elke byte op nul te zetten voordat het blok wordt teruggegeven. Dit maakt `calloc()` de natuurlijke keuze wanneer een programma een schoon, voorspelbaar geheugenblok nodig heeft voor een array of structuur waarvan de grootte alleen bekend is tijdens de uitvoering van de code.

Dynamische toewijzing met calloc() is geschikt voor diverse veelvoorkomende situaties:

• Numerieke arrays die bij nul moeten beginnen, zoals tellers, histogrammen of lopende accumulatoren.
• Datastructuren waarin achtergebleven, ongewenste waarden subtiele, moeilijk te detecteren problemen zouden veroorzaken.tracen insecten.
• Buffers waarvan de lengte afhangt van gebruikersinvoer of een bestand dat tijdens de uitvoering van het programma wordt gelezen.
• De blokken zijn te groot voor de beperkte stack, omdat calloc() geheugen uit de veel grotere heap haalt.

Omdat het gereserveerde blok aaneengesloten is en al met nullen is gevuld, kan het direct als een gebruiksklare array worden behandeld zonder aparte initialisatielus.

calloc() Syntaxis:

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

• Het bovenstaande instructievoorbeeld van calloc in C wordt gebruikt om n geheugenblokken van dezelfde grootte toe te wijzen.
• Nadat de geheugenruimte is toegewezen, worden alle bytes op nul geïnitialiseerd.
• De wijzer die zich momenteel op de eerste byte van de toegewezen geheugenruimte bevindt, wordt geretourneerd.

Telkens wanneer er een fout optreedt bij het toewijzen van geheugenruimte, zoals een tekort aan geheugen, wordt een nulaanwijzer geretourneerd, zoals weergegeven in het onderstaande calloc-voorbeeld.

Hoe calloc te gebruiken

Het onderstaande calloc-programma in C berekent de som van een rekenkundige reeks.

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

Resultaat van de calloc in C-voorbeeld:

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

Verschil tussen calloc() en malloc()

Zowel calloc() als malloc() reserveren geheugen op de heap en retourneren een void-pointer, of NULL bij een fout. Toch verschillen ze op drie praktische manieren die bepalen welke van de twee te gebruiken is.

• Initialisatie: calloc() zet elke byte in het nieuwe blok op nul, terwijl malloc() de inhoud niet-geïnitialiseerd laat. Een malloc()-blok bevat dus onvoorspelbare, ongewenste gegevens totdat het programma erin schrijft.
• Argumenten: calloc() neemt twee argumenten, het aantal elementen en de grootte van elk element, geschreven als calloc(n, grootte); malloc() neemt één argument, het totale aantal bytes, geschreven als malloc(n * grootte).
• Snelheid: malloc() is marginaal sneller omdat het de stap van het wissen van geheugen overslaat. Daarom geeft code die het geheugen direct overschrijft er vaak de voorkeur aan.

Beide functies zijn gedeclareerd in stdlib.h en beide geven hun geheugen vrij met dezelfde free()-functie. Kies voor calloc() wanneer een schoon, met nullen gevuld blok belangrijk is, en voor malloc() wanneer pure snelheid de voorkeur heeft en het programma de initialisatie zelf afhandelt.

Hoe geef ik geheugen vrij dat is toegewezen door calloc()?

Geheugen dat gereserveerd wordt door calloc() bevindt zich op de heap en wordt nooit automatisch vrijgegeven. Wanneer een programma continu geheugen toewijst zonder het vrij te geven, verbruikt het langzaam al het beschikbare geheugen. Dit defect staat bekend als een geheugenlek. De free()-functie geeft een vrijgekomen blok terug aan het systeem, zodat de ruimte opnieuw kan worden gebruikt voor latere toewijzingen.

De functie free() neemt één argument, de pointer die calloc() heeft geretourneerd, en geeft het hele blok in één keer vrij:

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

Volg deze regels om het geheugen van calloc() veilig te beheren:

• Roep free() precies één keer aan voor elke succesvolle calloc(); het tweemaal vrijgeven van hetzelfde blok leidt tot onvoorspelbaar gedrag.
• Stel de pointer na het vrijgeven in op NULL, zodat deze niet opnieuw als zwevende pointer kan worden gebruikt.
• Geef nooit een pointer vrij die niet door calloc() is geretourneerd, inclusief een pointer die is verschoven door pointer-aritmetiek.
• Zorg ervoor dat elke toewijzing wordt gekoppeld aan een vrijgave voordat de pointer buiten het bereik valt.

Omdat zowel calloc() als malloc() geheugen uit dezelfde heap halen, is het vrijgaveproces voor beide functies identiek: één free() voor elke succesvolle toewijzing, en daarna geen toegang meer tot het blok. Keeping Het evenwichtig toewijzen en vrijgeven van geheugen is de kern van handmatig geheugenbeheer in C en voorkomt zowel geheugenlekken als crashes die worden veroorzaakt door het hergebruiken van geheugen dat al is vrijgegeven.

Veelgestelde vragen