Dünaamiline mälu eraldamine C-s malloc(), calloc() funktsioonide abil

Enne C dünaamilise mälu eraldamise õppimist mõistame:

Kuidas mäluhaldus C-s töötab?

Kui deklareerite muutuja põhiandmetüübi abil, eraldab C-kompilaator muutuja jaoks automaatselt mäluruumi mälukogumis, mida nimetatakse Kestab.

Näiteks ujumuutuja deklareerimisel kulub tavaliselt 4 baiti (vastavalt platvormile). Saame seda teavet kontrollida, kasutades suurus operaator, nagu on näidatud allolevas näites

#include <stdio.h>
int main() { float x; printf("The size of float is %d bytes", sizeof(x)); return 0;}

Väljundiks on:

 The size of float is 4 bytes

Samuti eraldatakse kindla suurusega massiiv külgnevatesse mäluplokkidesse, igal plokil on ühe elemendi suurus:

#include <stdio.h>
int main() { float arr[10];
printf("The size of the float array with 10 element is %d", sizeof(arr)); return 0;}

Tulemuseks on:

 The size of the float array with 10 element is 40

Nagu seni teada, hallatakse põhiandmetüübi või massiivi deklareerimisel mälu automaatselt. Siiski on C-s mälu eraldamiseks protsess, mis võimaldab teil rakendada programmi, mille massiivi suurus on määramata, kuni programmi käivitate (tööaeg). Seda protsessi nimetatakse "Dünaamiline mälu eraldamine. "

Nüüd saate dünaamiliselt luua ja hävitada elementide massiivi käitusajal ilma probleemideta. Kokkuvõtteks võib öelda, et automaatne mäluhaldus kasutab virna ja C Dynamic Memory Allocation kasutab hunnikut.

The raamatukogul on dünaamilise mäluhalduse eest vastutavad funktsioonid.

funktsioon	Eesmärk
malloc ()	Eraldab soovitud suurusega mälu ja tagastab kursori faili esimesele baidile eraldatud ruum.
calloc()	Eraldab ruumi massiivi elementide jaoks. Lähtestab elemendid nulliks ja tagastab kursori mällu.
realloc()	Seda kasutatakse eelnevalt eraldatud mäluruumi suuruse muutmiseks.
Tasuta ()	Vabastab või tühjendab eelnevalt eraldatud mäluruumi.

Arutame ülaltoodud funktsioone koos nende rakendusega

Funktsiooni malloc() süntaks:

ptr = (cast_type *) malloc (byte_size);

Siin

• ptr on cast_type kursor.
• Funktsioon C malloc() tagastab kursori eraldatud mälule byte_size.

malloc() näide:

Example: ptr = (int *) malloc (50)

Kui see lause on edukalt täidetud, reserveeritakse 50 baiti suurune mäluruum. Reserveeritud ruumi esimese baidi aadress määratakse int tüüpi osutile ptr.

Mõelge veel ühele näitele:

#include <stdlib.h>
int main(){
int *ptr;
ptr = malloc(15 * sizeof(*ptr)); /* a block of 15 integers */
    if (ptr != NULL) {
      *(ptr + 5) = 480; /* assign 480 to sixth integer */
      printf("Value of the 6th integer is %d",*(ptr + 5));
    }
}

Väljund:

Value of the 6th integer is 480

1. Märka seda suurus(*ptr) asemel kasutati suurus (int) et muuta kood tugevamaks, kui *ptr-deklaratsioon sisestatakse hiljem mõnele teisele andmetüübile.
2. Jaotamine võib ebaõnnestuda, kui mälust ei piisa. Sel juhul tagastab see NULL osuti. Seega peaksite NULL-osuti kontrollimiseks lisama koodi.
3. Pidage meeles, et eraldatud mälu on külgnev ja seda saab käsitleda massiivina. Massiivielementidele juurdepääsuks saame kasutada kursori aritmeetikat, mitte kasutada sulgusid [ ]. Soovitame kasutada klahvi +, et viidata massiivi elementidele, kuna inkrementatsiooni ++ või += kasutamine muudab faili salvestatud aadressi. pointer.

Funktsiooni Malloc() saab kasutada ka nii märgi andmetüübi kui ka keerukate andmetüüpidega, näiteks struktuuridega.

Näiteks:

#include <stdio.h>
int main() {
int* ptr = malloc(10 * sizeof(*ptr));
if (ptr != NULL){
  *(ptr + 2) = 50;
  printf("Value of the 2nd integer is %d",*(ptr + 2));
}
free(ptr);
}

Väljund:

 Value of the 2nd integer is 50

Funktsiooni calloc() süntaks:

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

• Ülaltoodud lauset kasutatakse n sama suurusega mäluploki eraldamiseks.
• Pärast mäluruumi eraldamist lähtestatakse kõik baidid nulliks.
• Tagatakse kursor, mis on hetkel eraldatud mäluruumi esimesel baidil.

Kui mäluruumi eraldamisel ilmneb tõrge, näiteks mälupuudus, tagastatakse nullkursor.

Calloc() näide:

Allolev programm arvutab aritmeetilise jada summa.

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

Tulemus:

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

calloc() vs malloc(): Peamised erinevused

Järgmine on peamine erinevus malloc() vs calloc() C-s:

Funktsioon calloc() on üldiselt sobivam ja tõhusam kui malloc() funktsioon. Kuigi mõlemat funktsiooni kasutatakse mäluruumi eraldamiseks, saab calloc() eraldada mitu plokki korraga. Te ei pea iga kord mäluplokki taotlema. Funktsiooni calloc() kasutatakse keerukates andmestruktuurides, mis nõuavad suuremat mäluruumi.

C-s calloc()-ga eraldatud mäluplokk lähtestatakse alati nulliks, samas kui funktsiooni malloc() C-s sisaldab see alati prügiväärtust.

Funktsiooni realloc() süntaks:

ptr = realloc (ptr,newsize);

Ülaltoodud avaldus eraldab muutujas uudiste suuruses määratud suurusega uue mäluruumi. Pärast funktsiooni täitmist suunatakse kursor tagasi mäluploki esimesse baiti. Uus suurus võib olla suurem või väiksem kui eelmine mälu. Me ei saa olla kindlad, et kui äsja eraldatud plokk osutab samale asukohale, kus eelmine mäluplokk. See funktsioon kopeerib kõik varasemad andmed uues piirkonnas. See tagab andmete turvalisuse.

Realloc() näide:

#include <stdio.h>
int main () {
   char *ptr;
   ptr = (char *) malloc(10);
   strcpy(ptr, "Programming");
   printf(" %s,  Address = %u\n", ptr, ptr);

   ptr = (char *) realloc(ptr, 20); //ptr is reallocated with new size
   strcat(ptr, " In 'C'");
   printf(" %s,  Address = %u\n", ptr, ptr);
   free(ptr);
   return 0;
}

Kui realloc() C-s põhjustab ebaõnnestunud toimingu, tagastab see nullkursori ja ka eelmised andmed vabastatakse.

#include <stdio.h>
    int main() {
        int * arr_dynamic = NULL;
        int elements = 2, i;
        arr_dynamic = calloc(elements, sizeof(int)); //Array with 2 integer blocks
        for (i = 0; i < elements; i++) arr_dynamic[i] = i;
        for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);
        elements = 4;
        arr_dynamic = realloc(arr_dynamic, elements * sizeof(int)); //reallocate 4 elements
        printf("After realloc\n");
        for (i = 2; i < elements; i++) arr_dynamic[i] = i;
        for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);
        free(arr_dynamic);
    }

Programmi C Dynamic massiiv tulemus ekraanil:

 
arr_dynamic[0]=0
arr_dynamic[1]=1
After realloc
arr_dynamic[0]=0
arr_dynamic[1]=1
arr_dynamic[2]=2
arr_dynamic[3]=3

kokkuvõte

• Saame mälu dünaamiliselt hallata, luues hunnikusse vastavalt vajadusele mäluplokke
• Funktsioonis C Dynamic Memory Allocation eraldatakse mälu käitusajal.
• Dünaamiline mälujaotus võimaldab manipuleerida stringide ja massiividega, mille suurus on paindlik ja mida saab programmis igal ajal muuta.
• See on vajalik, kui teil pole aimugi, kui palju mälu konkreetne struktuur hõivab.
• Malloc() C-s on dünaamiline mälu jaotamise funktsioon, mis tähistab mälu eraldamist, mis blokeerib konkreetse suurusega mälu, mis on lähtestatud prügiväärtuseks
• Calloc() C-s on külgnev mälu jaotamise funktsioon, mis eraldab korraga mitu mäluplokki, mis on lähtestatud väärtusega 0
• Realloc() C-s kasutatakse mälu ümberjaotamiseks vastavalt määratud suurusele.
• Funktsiooni Free() kasutatakse dünaamiliselt eraldatud mälu tühjendamiseks.