Dynamisk hukommelsesallokering i C ved hjælp af malloc(), calloc()-funktioner

Før du lærer C Dynamic Memory allokering, lad os forstå:

Hvordan fungerer hukommelsesstyring i C?

Når du erklærer en variabel ved hjælp af en grundlæggende datatype, tildeler C-kompileren automatisk hukommelsesplads til variablen i en pulje af hukommelse kaldet stable.

For eksempel tager en float-variabel typisk 4 bytes (ifølge platformen), når den er deklareret. Vi kan verificere disse oplysninger ved hjælp af størrelse på operatør som vist i nedenstående eksempel

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

Outputtet vil være:

 The size of float is 4 bytes

Et array med en specificeret størrelse er også allokeret i sammenhængende hukommelsesblokke, hver blok har størrelsen for ét element:

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

Resultatet er:

 The size of the float array with 10 element is 40

Som hidtil erfaret, administreres hukommelsen automatisk, når en grundlæggende datatype eller et array deklareres. Der er dog en proces til at allokere hukommelse i C, som vil tillade dig at implementere et program, hvor array-størrelsen er uafklaret, indtil du kører dit program (runtime). Denne proces kaldes "Dynamisk hukommelsestildeling".

Nu kan du oprette og ødelægge en række elementer dynamisk under kørsel uden problemer. For at opsummere bruger den automatiske hukommelsesstyring stakken, og C Dynamic Memory Allocation bruger heapen.

Det biblioteket har funktioner, der er ansvarlige for Dynamic Memory Management.

Funktion	Formål
malloc ()	Tildeler hukommelsen af ​​den ønskede størrelse og returnerer markøren til den første byte af tildelt plads.
calloc()	Tildeler plads til elementer i et array. Initialiserer elementerne til nul og returnerer en markør til hukommelsen.
realloc()	Det bruges til at ændre størrelsen af ​​tidligere tildelt hukommelsesplads.
Gratis()	Frigør eller tømmer den tidligere tildelte hukommelsesplads.

Lad os diskutere ovenstående funktioner med deres anvendelse

Syntaks for malloc() Funktion:

ptr = (cast_type *) malloc (byte_size);

Her,

• ptr er en pointer af cast_type.
• Funktionen C malloc() returnerer en pointer til den tildelte hukommelse af byte_size.

Eksempel på malloc():

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

Når denne sætning er udført, er der reserveret en hukommelsesplads på 50 bytes. Adressen på den første byte af reserveret plads er tildelt til pointeren ptr af typen int.

Overvej et andet eksempel:

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

Output:

Value of the 6th integer is 480

1. Læg mærke til det sizeof(*ptr) blev brugt i stedet for størrelse på (int) for at gøre koden mere robust, når *ptr-deklarationen typecastes til en anden datatype senere.
2. Tildelingen kan mislykkes, hvis hukommelsen ikke er tilstrækkelig. I dette tilfælde returnerer den en NULL-markør. Så du bør inkludere kode for at tjekke for en NULL-pointer.
3. Husk, at den allokerede hukommelse er sammenhængende, og den kan behandles som en matrix. Vi kan bruge pointer-aritmetik til at få adgang til array-elementerne i stedet for at bruge parenteser [ ]. Vi anbefaler at bruge + til at henvise til array-elementer, fordi brug af inkrementering ++ eller += ændrer adressen gemt af pointer.

Malloc()-funktionen kan også bruges med karakterdatatypen såvel som komplekse datatyper såsom strukturer.

For eksempel:

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

Output:

 Value of the 2nd integer is 50

Syntaks for calloc() Funktion:

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

• Ovenstående sætning bruges til at allokere n hukommelsesblokke af samme størrelse.
• Efter at hukommelsespladsen er allokeret, initialiseres alle bytes til nul.
• Den pointer, der 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-markør.

Eksempel på calloc():

Programmet nedenfor beregner summen af ​​en aritmetisk rækkefølge.

#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:

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

calloc() vs. malloc(): Nøgleforskelle

Følgende er den vigtigste forskel mellem malloc() vs calloc() i C:

Calloc()-funktionen er generelt mere egnet og effektiv end malloc()-funktionen. Mens begge funktioner bruges til at allokere hukommelsesplads, kan calloc() allokere flere blokke på én gang. Du behøver ikke at anmode om en hukommelsesblok hver gang. Calloc()-funktionen bruges i komplekse datastrukturer, som kræver større hukommelsesplads.

Hukommelsesblokken tildelt af en calloc() i C initialiseres altid til nul, mens den i funktionen malloc() i C altid indeholder en skraldværdi.

Syntaks for realloc() Funktion:

ptr = realloc (ptr,newsize);

Ovenstående sætning tildeler en ny hukommelsesplads med en specificeret størrelse i variablen nyhedsstørrelse. Efter udførelse af funktionen vil markøren blive returneret til den første byte i hukommelsesblokken. Den nye størrelse kan være større eller mindre end den tidligere hukommelse. Vi kan ikke være sikre på, at hvis den nyligt allokerede blok vil pege på den samme placering som den for den tidligere hukommelsesblok. Denne funktion kopierer alle tidligere data i den nye region. Det sikrer, at data forbliver sikre.

Eksempel på realloc():

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

Når realloc() i C resulterer i en mislykket operation, returnerer den en null-pointer, og de tidligere data frigives også.

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

Resultat af C Dynamic array-program på skærmen:

 
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

Resumé

• Vi kan dynamisk styre hukommelsen ved at oprette hukommelsesblokke efter behov i heapen
• I C Dynamic Memory Allocation allokeres hukommelse på et kørselstidspunkt.
• Dynamisk hukommelsesallokering tillader at manipulere strenge og arrays, hvis størrelse er fleksibel og kan ændres når som helst i dit program.
• Det er påkrævet, når du ikke har nogen idé om, hvor meget hukommelse en bestemt struktur kommer til at optage.
• Malloc() i C er en dynamisk hukommelsesallokeringsfunktion, der står for hukommelsesallokering, der hukommelsesblokke med den specifikke størrelse initialiseret til en skraldværdi
• Calloc() i C er en sammenhængende hukommelsesallokeringsfunktion, der allokerer flere hukommelsesblokke ad gangen initialiseret til 0
• Realloc() i C bruges til at omallokere hukommelse i henhold til den angivne størrelse.
• Free()-funktionen bruges til at rydde den dynamisk allokerede hukommelse.