Dynamische geheugentoewijzing in C met behulp van malloc(), calloc()-functies

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

Hoe geheugenbeheer in C werkt?

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

Een float-variabele neemt bijvoorbeeld doorgaans 4 bytes in beslag (afhankelijk van het platform) wanneer deze wordt gedeclareerd. We kunnen deze informatie verifiëren met behulp van de De grootte van operazoals weergegeven in onderstaand voorbeeld

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

De output zal worden:

 The size of float is 4 bytes

Ook wordt een array met een gespecificeerde grootte toegewezen in aaneengesloten geheugenblokken, waarbij elk blok de grootte heeft 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 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 waarvan de arraygrootte onbeslist is totdat u het programma uitvoert (runtime). Dit proces heet “Dynamische geheugentoewijzing. '

Dynamische geheugentoewijzing in C

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

Nu kunt u zonder problemen een reeks elementen tijdens runtime dynamisch creëren en vernietigen. Samenvattend: het automatische geheugenbeheer maakt gebruik van 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 pointer 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 verwijzing naar het geheugen.
realloc() Het wordt gebruikt om de grootte van eerder toegewezen geheugenruimte te wijzigen.
Vrij() Maakt de eerder toegewezen geheugenruimte vrij of leegt deze.

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 een opgegeven grootte en retourneert de nulaanwijzer die naar de geheugenlocatie wijst. De geretourneerde pointer is meestal van het type void. Het betekent dat we de C malloc()-functie 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 verwijzing naar het toegewezen geheugen van byte_size.

Voorbeeld van malloc():

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

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

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

Output:

Value of the 6th integer is 480

C malloc() Functie

  1. Let erop dat groottevan(*ptr) werd gebruikt in plaats van groottevan(int) om de code robuuster te maken wanneer de *ptr-declaratie naar een ander gegevenstype wordt getypeerd later.
  2. De toewijzing kan mislukken als er niet voldoende geheugen is. In dit geval retourneert het een NULL-aanwijzer. U moet dus code toevoegen 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-berekeningen gebruiken om toegang te krijgen tot de array-elementen in plaats van te gebruiken brackets [ ]. We adviseren om + te gebruiken om naar array-elementen te verwijzen, omdat het gebruik van incrementatie ++ of += het adres verandert dat is opgeslagen door de wijzer.

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

free()-functie in C

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

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

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

Output:

 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 aan com toe te wijzenplex gegevensstructuren 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 dat wordt toegewezen door de functie calloc() 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 op nul geïnitialiseerd.
  • De pointer 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.

Voorbeeld van calloc():

Het onderstaande programma 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:

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

calloc() versus malloc(): Belangrijkste verschillen

Following is 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 calloc()-functie wordt gebruikt in complex datastructuren die een grotere geheugenruimte vereisen.

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

realloc()-functie in C

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

realloc() kan ook worden gebruikt om de grootte 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 keert de pointer terug naar de eerste byte van het geheugenblok. Het nieuwe formaat kan groter of kleiner zijn dan het vorige geheugen. We kunnen er niet zeker van zijn dat het nieuw toegewezen blok naar dezelfde locatie zal verwijzen als die van het vorige geheugenblok. Deze functie kopieert alle eerdere gegevens in 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 operaHet retourneert een null-pointer en de eerdere gegevens worden ook vrijgegeven.

Dynamische arrays in C

Met een dynamische array in C kan het aantal elementen naar behoefte groeien. C Dynamische array wordt veel gebruikt in de informatica algorithms.

In het vervolgwing programma hebben we een dynamische array gemaakt en de grootte ervan aangepast 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

Samengevat

  • We kunnen het geheugen dynamisch beheren door indien nodig geheugenblokken in de heap te creëren
  • Bij C Dynamic Memory Allocation wordt geheugen tijdens runtime toegewezen.
  • 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.
  • Dit is nodig als u geen idee heeft 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 op 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.