Dynamische geheugentoewijzing in C met malloc(), calloc() Functies

Voordat u C Dynamic Memory-toewijzing leert, moeten we het volgende begrijpen:

Hoe werkt geheugenbeheer in C?

Wanneer u een variabele declareert met een basisgegevenstype, wijst de C-compiler automatisch geheugenruimte toe voor de variabele in een geheugenpool die de stack wordt genoemd. .

Een float-variabele duurt bijvoorbeeld typisch 4 bytes (volgens het platform) wanneer deze wordt gedeclareerd. We kunnen deze informatie verifiëren met behulp van de sizeof operator zoals getoond in onderstaand voorbeeld

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

De uitvoer zal zijn:

 The size of float is 4 bytes

Ook wordt een array met een gespecificeerde grootte toegewezen in aaneengesloten geheugenblokken, elk blok heeft de grootte voor één 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;}

Het resultaat is:

 The size of the float array with 10 element is 40

Zoals tot nu toe is geleerd, wordt het geheugen automatisch beheerd bij het declareren van een basisgegevenstype of een array. Er is echter een proces voor het toewijzen van geheugen in C waarmee u een programma kunt implementeren waarin de grootte van de array onbeslist is totdat u uw programma uitvoert (runtime). Dit proces heet "Dynamische geheugentoewijzing .”

In deze tutorial leer je-

• Hoe geheugenbeheer in C werkt?
• Dynamische geheugentoewijzing in C
• malloc() functie in C
• free() functie in C
• calloc() functie in C
• calloc() vs. malloc():Belangrijkste verschillen
• realloc()-functie in C
• Dynamische arrays

Dynamische geheugentoewijzing in C

Dynamische geheugentoewijzing is handmatige toewijzing en het vrijmaken van geheugen volgens uw programmeerbehoeften. Dynamisch geheugen wordt beheerd en bediend met pointers die verwijzen naar de nieuw toegewezen geheugenruimte in een gebied dat we de heap noemen.

Nu kunt u zonder problemen een reeks elementen dynamisch tijdens runtime maken en vernietigen. Kortom, het automatische geheugenbeheer gebruikt de stapel en de C Dynamic Memory Allocation gebruikt de heap.

De bibliotheek heeft functies die verantwoordelijk zijn voor dynamisch geheugenbeheer.

Functie Doel malloc() Wijst het geheugen van de gevraagde grootte toe en retourneert de aanwijzer naar de eerste byte van
toegewezen ruimte.calloc() Wijst de ruimte toe voor elementen van een array. Initialiseert de elementen naar nul en retourneert een pointer naar het geheugen.realloc() Het wordt gebruikt om de grootte van eerder toegewezen geheugenruimte te wijzigen.Free() Maakt de eerder toegewezen geheugenruimte vrij of leeg.

Laten we de bovenstaande functies bespreken met hun toepassing

malloc() functie in C

De functie C malloc() staat voor geheugentoewijzing. Het is een functie die wordt gebruikt om een ​​geheugenblok dynamisch toe te wijzen. Het reserveert geheugenruimte van de opgegeven grootte en retourneert de null-aanwijzer die naar de geheugenlocatie wijst. De geretourneerde aanwijzer is meestal van het type void. Het betekent dat we de functie C malloc() aan elke aanwijzer kunnen toewijzen.

Syntaxis van malloc() Functie:

ptr = (cast_type *) malloc (byte_size);

Hier,

• ptr is een pointer van cast_type.
• De functie C malloc() retourneert een pointer naar het toegewezen geheugen van byte_size.

Voorbeeld van malloc():

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

Wanneer deze instructie met succes wordt uitgevoerd, wordt een geheugenruimte van 50 bytes gereserveerd. Het adres van de eerste byte gereserveerde ruimte wordt toegewezen aan de pointer ptr van het type int.

Bekijk een ander voorbeeld:

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

Uitvoer:

Value of the 6th integer is 480

1. Merk op dat sizeof(*ptr) werd gebruikt in plaats van sizeof(int) om de code robuuster te maken wanneer *ptr-declaratie later wordt getypecast naar een ander gegevenstype.
2. De toewijzing kan mislukken als het geheugen niet voldoende is. In dit geval wordt een NULL-aanwijzer geretourneerd. U moet dus code opnemen om te controleren op een NULL-aanwijzer.
3. Houd er rekening mee dat het toegewezen geheugen aaneengesloten is en als een array kan worden behandeld. We kunnen pointer-rekenkunde gebruiken om toegang te krijgen tot de array-elementen in plaats van haakjes [ ]. We raden aan om + te gebruiken om naar array-elementen te verwijzen, omdat het gebruik van incrementatie ++ of +=het adres verandert dat door de aanwijzer is opgeslagen.

De functie Malloc() kan ook worden gebruikt met het karaktergegevenstype en met complexe gegevenstypen zoals structuren.

free() functie in C

Het geheugen voor variabelen wordt automatisch ongedaan gemaakt tijdens het compileren. Bij dynamische geheugentoewijzing moet u de toewijzing van geheugen expliciet ongedaan maken. Als u dit niet doet, kunt u een geheugenfout tegenkomen.

De gratis() functie wordt aangeroepen om geheugen in C vrij te geven/vrij te maken. Door geheugen in uw programma vrij te maken, maakt u meer beschikbaar voor later gebruik.

Bijvoorbeeld:

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

Uitvoer

 Value of the 2nd integer is 50

calloc() functie in C

De functie C calloc() staat voor aaneengesloten toewijzing. Deze functie wordt gebruikt om meerdere geheugenblokken toe te wijzen. Het is een dynamische geheugentoewijzingsfunctie die wordt gebruikt om het geheugen toe te wijzen aan complexe datastructuren zoals arrays en structuren.

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

Syntaxis van calloc() Functie:

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

• De bovenstaande verklaring wordt gebruikt om n geheugenblokken van dezelfde grootte toe te wijzen.
• Nadat de geheugenruimte is toegewezen, worden alle bytes geïnitialiseerd op nul.
• De aanwijzer 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 null-pointer geretourneerd.

Voorbeeld van calloc():

Het onderstaande programma berekent de som van een rekenkundige rij.

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

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

calloc() vs. malloc():belangrijkste verschillen

Hieronder volgt het belangrijkste verschil tussen malloc() versus calloc() in C:

De functie calloc() is over het algemeen geschikter en efficiënter dan die van de functie malloc(). Hoewel beide functies worden gebruikt om geheugenruimte toe te wijzen, kan calloc() meerdere blokken tegelijk toewijzen. U hoeft niet elke keer een geheugenblok aan te vragen. De functie calloc() wordt gebruikt in complexe datastructuren die meer geheugen nodig hebben.

Het geheugenblok dat door een calloc() in C is toegewezen, wordt altijd op nul geïnitialiseerd, terwijl het in de functie malloc() in C altijd een afvalwaarde bevat.

realloc()-functie in C

De C realloc() . gebruiken functie, kunt u meer geheugen toevoegen aan het reeds toegewezen geheugen. Het breidt het huidige blok uit terwijl het de originele inhoud laat zoals het is. realloc() in C staat voor hertoewijzing van geheugen.

realloc() kan ook worden gebruikt om de omvang van het eerder toegewezen geheugen te verkleinen.

Syntaxis van realloc()-functie:

ptr = realloc (ptr,newsize);

De bovenstaande instructie wijst een nieuwe geheugenruimte toe met een gespecificeerde grootte in de variabele newsize. Na het uitvoeren van de functie wordt de aanwijzer teruggezet naar de eerste byte van het geheugenblok. De nieuwe grootte kan groter of kleiner zijn dan het vorige geheugen. We kunnen er niet zeker van zijn of het nieuw toegewezen blok naar dezelfde locatie zal wijzen als die van het vorige geheugenblok. Deze functie kopieert alle eerdere gegevens naar de nieuwe regio. Het zorgt ervoor dat gegevens veilig blijven.

Voorbeeld van 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;
}

Telkens wanneer de realloc() in C resulteert in een mislukte bewerking, retourneert het een null-pointer en worden de vorige gegevens ook vrijgegeven.

Dynamische arrays in C

Met een dynamische array in C kan het aantal elementen naar behoefte groeien. C Dynamische arrays worden veel gebruikt in computerwetenschappelijke algoritmen.

In het volgende programma hebben we een dynamische array gemaakt en vergroot/verkleind in C

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

Resultaat van C Dynamic array-programma op het scherm:

 
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

Samenvatting

• We kunnen het geheugen dynamisch beheren door zo nodig geheugenblokken in de heap te maken
• In C Dynamic Memory Allocation wordt geheugen toegewezen tijdens runtime.
• Dynamische geheugentoewijzing maakt het mogelijk om strings en arrays te manipuleren waarvan de grootte flexibel is en op elk moment in uw programma kan worden gewijzigd.
• Het is vereist als je geen idee hebt hoeveel geheugen een bepaalde structuur in beslag gaat nemen.
• Malloc() in C is een dynamische geheugentoewijzingsfunctie die staat voor geheugentoewijzing waarbij geheugenblokken met de specifieke grootte worden geïnitialiseerd tot een afvalwaarde
• Calloc() in C is een aaneengesloten geheugentoewijzingsfunctie die meerdere geheugenblokken tegelijk toewijst, geïnitialiseerd op 0
• Realloc() in C wordt gebruikt om geheugen opnieuw toe te wijzen volgens de opgegeven grootte.
• De functie Free() wordt gebruikt om het dynamisch toegewezen geheugen te wissen.