Dynamisk minnetildeling i C: Funksjoner malloc (), calloc ()

Før du lærer C Dynamic Memory-tildeling, la oss forstå:

Hvordan fungerer Memory Management i C?

Når du deklarerer en variabel ved hjelp av en grunnleggende datatype, tildeler C-kompilatoren automatisk minneplass for variabelen i et minnesamling som kalles stabelen .

For eksempel tar en flytvariabel vanligvis 4 byte (i henhold til plattformen) når den blir erklært. Vi kan bekrefte denne informasjonen ved hjelp av størrelsen på operatøren som vist i eksemplet nedenfor

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

Resultatet blir:

 The size of float is 4 bytes

Dessuten er en matrise med en spesifisert størrelse tildelt i sammenhengende blokker av minne, hver blokk har størrelsen for ett element:

#include 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 kjent så langt, blir minnet automatisk administrert når du deklarerer en grunnleggende datatype eller en matrise. Imidlertid er det en prosess for tildeling av minne i C som vil tillate deg å implementere et program der matrisestørrelsen er ubestemt til du kjører programmet ditt (kjøretid). Denne prosessen kalles " Dynamisk minnetildeling ."

I denne veiledningen vil du lære-

Hvordan fungerer Memory Management i C?
Dynamisk minnetildeling i C
C malloc () Funksjon
Den gratis () funksjonen
C calloc () -funksjon
calloc () vs. malloc (): Viktige forskjeller
C realloc () Funksjon
Dynamiske matriser

Dynamisk minnetildeling i C

Dynamisk minnetildeling er manuell tildeling og frigjøring av minne i henhold til dine programmeringsbehov. Dynamisk minne styres og serveres med pekere som peker på det nylig tildelte minneplassen i et område som vi kaller haugen.

Nå kan du opprette og ødelegge en rekke elementer dynamisk ved kjøretid uten problemer. For å oppsummere bruker automatisk minnestyring stakken, og C Dynamic Memory Allocation bruker bunken.

biblioteket har funksjoner som er ansvarlige for Dynamic Memory Management.

Funksjon	Hensikt
malloc ()	Tildeler minnet med ønsket størrelse og returnerer pekeren til den første byten med tildelt plass.
calloc ()	Tildel plass til elementer i en matrise. Initialiserer elementene til null og returnerer en peker til minnet.
realloc ()	Den brukes til å endre størrelsen på tidligere tildelt minne.
Gratis()	Frigjør eller tømmer den tidligere tildelte minneplassen.

La oss diskutere funksjonene ovenfor med applikasjonen

C malloc () Funksjon

Funksjonen C malloc () står for minnetildeling. Det er en funksjon som brukes til å fordele en blokk med minne dynamisk. Den reserverer minneplass av spesifisert størrelse og returnerer nullpekeren som peker til minneplasseringen. Pekeren som returneres er vanligvis ugyldig. Det betyr at vi kan tilordne C malloc () -funksjon til en hvilken som helst peker.

Syntaks for malloc () Funksjon:

ptr = (cast_type *) malloc (byte_size);

Her,

ptr er en peker av cast_type.
Funksjonen C malloc () returnerer en peker til det tildelte minnet til byte_size.

Eksempel på malloc ():

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

Når denne utsagnet er utført, er det lagret et minne på 50 byte. Adressen til den første byten med reservert plass tildeles pekeren ptr av typen int.

Tenk på et annet eksempel:

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

Produksjon:

Value of the 6th integer is 480

Legg merke til at sizeof (* ptr) ble brukt i stedet for sizeof (int) for å gjøre koden mer robust når * ptr-erklæringen blir typecastet til en annen datatype senere.
Tildelingen kan mislykkes hvis minnet ikke er tilstrekkelig. I dette tilfellet returnerer den en NULL-peker. Så du bør ta med kode for å se etter en NULL-peker.
Husk at det tildelte minnet er sammenhengende, og det kan behandles som en matrise. Vi kan bruke pekeraritmetikk for å få tilgang til matriseelementene i stedet for å bruke parenteser []. Vi anbefaler å bruke + for å referere til matriseelementer fordi bruk av inkrementering ++ eller + = endrer adressen som er lagret av pekeren.

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

Den gratis () funksjonen

Hukommelsen for variabler distribueres automatisk ved kompileringstidspunktet. I dynamisk minnetildeling må du distribuere minne eksplisitt. Hvis det ikke er gjort, kan det oppstå minnefeil.

Den gratis () -funksjonen kalles for å frigjøre / distribuere minne i C. Ved å frigjøre minne i programmet ditt, gjør du mer tilgjengelig for bruk senere.

For eksempel:

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

Produksjon

 Value of the 2nd integer is 50

C calloc () -funksjon

Funksjonen C calloc () står for sammenhengende tildeling. Denne funksjonen brukes til å tildele flere blokker med minne. Det er en dynamisk minnetildelingsfunksjon som brukes til å tildele minnet til komplekse datastrukturer som matriser og strukturer.

Malloc () -funksjonen brukes til å tildele en enkelt minneplass mens calloc () i C brukes til å tildele flere blokker med minneplass. Hver blokk tildelt av calloc () -funksjonen har samme størrelse.

Syntaks for calloc () Funksjon:

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

Ovennevnte uttalelse brukes til å tildele n minneblokker av samme størrelse.
Etter at minneplassen er tildelt, initialiseres alle byte til null.
Pekeren som for øyeblikket er ved den første byten i det tildelte minneplassen, returneres.

Hver gang det oppstår en feil ved tildeling av minneplass, for eksempel mangel på minne, returneres en nullpeker.

Eksempel på calloc ():

Programmet nedenfor beregner summen av en aritmetisk sekvens.

#include 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 termsSum = 45

calloc () vs. malloc (): Viktige forskjeller

Følgende er nøkkelforskjellen mellom malloc () Vs calloc () i C:

Calloc () -funksjonen er generelt mer passende og effektiv enn malloc () -funksjonen. Mens begge funksjonene brukes til å tildele minne, kan calloc () tildele flere blokker på en gang. Du trenger ikke be om en minneblokk hver gang. Calloc () -funksjonen brukes i komplekse datastrukturer som krever større minne.

Minneblokken allokert av en calloc () i C initialiseres alltid til null mens den i funksjon malloc () i C inneholder alltid en søppelverdi.

C realloc () Funksjon

Ved å bruke C realloc () -funksjonen kan du legge til mer minnestørrelse i allerede tildelt minne. Den utvider den nåværende blokken mens den lar originalinnholdet være som det er. realloc () i C står for omdisponering av minne.

realloc () kan også brukes til å redusere størrelsen på det tidligere tildelte minnet.

Syntaks for realloc () Funksjon:

ptr = realloc (ptr,newsize);

Ovennevnte uttalelse tildeler et nytt minne med en spesifisert størrelse i variabelen nyhetsstørrelse. Etter at funksjonen er utført, vil pekeren returneres til den første byten i minneblokken. Den nye størrelsen kan være større eller mindre enn forrige minne. Vi kan ikke være sikre på at hvis den nylig tildelte blokken vil peke til samme sted som den forrige minneblokken. Denne funksjonen kopierer alle tidligere data i den nye regionen. Det sørger for at data forblir trygge.

Eksempel på realloc ():

#include 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 sizestrcat(ptr, " In 'C'");printf(" %s, Address = %u\n", ptr, ptr);free(ptr);return 0;}

Hver gang realloc () i C resulterer i en mislykket operasjon, returnerer den en nullpeker, og de forrige dataene blir også frigjort.

Dynamiske matriser i C

En dynamisk matrise i C lar antall elementer vokse etter behov. C Dynamic array brukes mye i datavitenskapelige algoritmer.

I det følgende programmet har vi opprettet og endret størrelse på en dynamisk matrise i C

#include int main() {int * arr_dynamic = NULL;int elements = 2, i;arr_dynamic = calloc(elements, sizeof(int)); //Array with 2 integer blocksfor (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 elementsprintf("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 av C Dynamic array-program på skjermen:

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

Sammendrag

Vi kan dynamisk administrere minne ved å lage minneblokker etter behov i dyngen
I C Dynamic Memory Allocation tildeles minne på en kjøretid.
Dynamisk minnetildeling tillater manipulering av strenger og matriser hvis størrelse er fleksibel og kan endres når som helst i programmet.
Det kreves når du ikke aner hvor mye minne en bestemt struktur kommer til å okkupere.
Malloc () i C er en dynamisk minnetildelingsfunksjon som står for minnetildeling som blokkerer minne med den spesifikke størrelsen initialisert til en søppelverdi.
Calloc () i C er en sammenhengende minnetildelingsfunksjon som tildeler flere minneblokker om gangen initialisert til 0
Realloc () i C brukes til å omdisponere minne i henhold til den angitte størrelsen.
Free () -funksjonen brukes til å tømme det dynamisk tildelte minnet.