Funcția calloc() în Biblioteca C cu programul EXEMPLUL

Ce este calloc în C?

Funcția calloc() din C este utilizată pentru a aloca mai multe blocuri de memorie de aceeași dimensiune. Este o funcție de alocare dinamică a memoriei care alocă spațiul de memorie structurilor de date complexe, cum ar fi tablouri și structuri, și returnează un pointer void către memorie. Calloc înseamnă alocare contiguă.

Funcția Malloc este folosită pentru a aloca un singur bloc de spațiu de memorie, în timp ce funcția calloc din C este folosită pentru a aloca mai multe blocuri de spațiu de memorie. Fiecare bloc alocat de calloc în programarea C este de aceeași dimensiune.

De ce se folosește calloc() în C?

Variabilele ordinare și tablourile cu dimensiune fixă ​​își blochează dimensiunile atunci când programul este compilat, ceea ce irosește spațiu atunci când sunt necesare mai puține elemente și eșuează complet atunci când sunt necesare mai multe. calloc() elimină această limită prin rezervarea memoriei la momentul execuției și, spre deosebire de malloc(), șterge fiecare octet la zero înainte de a returna blocul. Acest lucru face ca calloc() să fie alegerea naturală ori de câte ori un program are nevoie de o regiune de memorie curată și previzibilă pentru un tablou sau o structură a cărei dimensiune este cunoscută doar în timp ce codul rulează.

Alocarea dinamică cu calloc() se potrivește mai multor situații comune:

• Tablouri numerice care ar trebui să înceapă de la zero, cum ar fi contoare, histograme sau acumulatoare care rulează.
• Structuri de date în care valorile reziduale rămase ar cauza erori subtile, greu detracși insecte.
• Buffera căror lungime depinde de datele introduse de utilizator sau de un fișier citit în timp ce programul rulează.
• Blocuri prea mari pentru stiva limitată, deoarece calloc() extrage informații din heap-ul mult mai mare.

Deoarece blocul rezervat este contiguu și deja adus la zero, acesta poate fi tratat imediat ca un tablou gata de utilizare, fără o buclă de inițializare separată.

calloc() Sintaxă:

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

• Exemplul de declarație de mai sus de calloc în C este folosit pentru a aloca n blocuri de memorie de aceeași dimensiune.
• După ce spațiul de memorie este alocat, toți octeții sunt inițializați la zero.
• indicatorul care se află în prezent la primul octet al spațiului de memorie alocat este returnat.

Ori de câte ori există o eroare la alocarea spațiului de memorie, cum ar fi lipsa de memorie, atunci este returnat un pointer nul, așa cum se arată în exemplul calloc de mai jos.

Cum se folosește calloc

Programul calloc de mai jos în C calculează suma unei secvențe aritmetice.

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

Rezultatul calloc-ului în exemplu C:

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

Diferența dintre calloc() și malloc()

Atât calloc() cât și malloc() rezervă memorie pe heap și ambele returnează un pointer void sau NULL în caz de eșec, însă diferă în trei moduri practice care decid pe care să o utilizeze.

• Inițializare: calloc() setează fiecare octet din noul bloc la zero, în timp ce malloc() lasă conținutul neinițializat, astfel încât un bloc malloc() reține date imprevizibile până când programul scrie în el.
• Argumente: calloc() primește două argumente, numărul de elemente și dimensiunea fiecăruia, scrise calloc(n, size); malloc() primește un singur argument, numărul total de octeți, scris malloc(n * size).
• Viteză: malloc() este puțin mai rapidă deoarece omite pasul de zeroare, motiv pentru care codul care suprascrie imediat memoria o preferă adesea.

Ambele funcții sunt declarate în stdlib.h și ambele își eliberează memoria cu aceeași funcție free(). Alegeți calloc() atunci când contează un bloc curat, adus la zero, și malloc() atunci când se preferă viteza brută și programul se ocupă de inițializare.

Cum se eliberează memoria alocată prin calloc()

Memoria rezervată de calloc() se află în heap și nu este niciodată eliberată automat. Când un program continuă să aloce fără a elibera, consumă lent toată memoria disponibilă, un defect cunoscut sub numele de scurgere de memorie. Funcția free() returnează un bloc finalizat sistemului, astfel încât spațiul să poată fi reutilizat prin alocări ulterioare.

Funcția free() primește un singur argument, pointerul returnat de calloc(), și eliberează întregul bloc dintr-o dată:

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

Urmați aceste reguli pentru a gestiona memoria calloc() în siguranță:

• Apelează free() exact o dată pentru fiecare apel calloc() reușit; eliberarea aceluiași bloc de două ori provoacă un comportament nedefinit.
• Setați indicatorul la NULL după eliberare, astfel încât să nu poată fi reutilizat ca indicator suspendat.
• Nu eliberează niciodată() un pointer pe care calloc() nu l-a returnat, inclusiv unul deplasat prin aritmetica pointerului.
• Potrivește fiecare alocare cu o versiune înainte ca indicatorul să iasă din domeniul de aplicare.

Deoarece atât calloc() cât și malloc() extrag din aceeași heap, disciplina de eliberare este identică pentru oricare dintre funcții: o comandă free() pentru fiecare alocare reușită și niciun acces la bloc ulterior. Păstrațiping Alocarea și eliberarea în echilibru este obiceiul de bază al gestionării manuale a memoriei în C și previne atât scurgerile de date, cât și blocările cauzate de reutilizarea memoriei deja returnate.

Întrebări frecvente