Innan du lär dig C Dynamic Memory allocation, låt oss förstå:
Hur fungerar Memory Management i C?
När du deklarerar en variabel med en grundläggande datatyp tilldelar C-kompilatorn automatiskt minnesutrymme för variabeln i en minnespool som kallas stacken .
Till exempel tar en flytvariabel vanligtvis 4 byte (enligt plattformen) när den deklareras. Vi kan verifiera denna information med hjälp av operatörens storlek som visas i exemplet nedan
#includeint main() { float x; printf("The size of float is %d bytes", sizeof(x)); return 0;}
Utgången blir:
The size of float is 4 bytes
Dessutom tilldelas en matris med en specificerad storlek i angränsande minnesblock, varje block har storleken för ett element:
#includeint main() { float arr[10];printf("The size of the float array with 10 element is %d", sizeof(arr)); return 0;}
Resultatet är:
The size of the float array with 10 element is 40
Som hittills lärt sig hanteras minnet automatiskt när man deklarerar en grundläggande datatyp eller en matris. Det finns emellertid en process för att allokera minne i C som gör att du kan implementera ett program där matrisstorleken är obestämd tills du kör ditt program (runtime). Denna process kallas " Dynamisk minnestilldelning ."
I den här handledningen lär du dig-
- Hur fungerar Memory Management i C?
- Dynamisk minnesallokering i C
- C malloc () Funktion
- Den fria () funktionen
- C calloc () -funktion
- calloc () vs. malloc (): Viktiga skillnader
- C realloc () -funktion
- Dynamiska matriser
Dynamisk minnesallokering i C
Dynamisk minnestilldelning är manuell allokering och frigöring av minne enligt dina programmeringsbehov. Dynamiskt minne hanteras och serveras med pekare som pekar på det nyligen tilldelade minnesutrymmet i ett område som vi kallar högen.
Nu kan du skapa och förstöra en rad element dynamiskt vid körning utan problem. Sammanfattningsvis använder den automatiska minneshanteringen stacken och C Dynamic Memory Allocation använder heapen.
| Fungera | Ändamål |
| malloc () | Tilldelar minnet med önskad storlek och returnerar pekaren till den första byten med tilldelat utrymme. |
| calloc () | Tilldelar utrymmet för element i en matris. Initierar elementen till noll och returnerar en pekare till minnet. |
| realloc () | Den används för att ändra storleken på tidigare tilldelat minnesutrymme. |
| Fri() | Frigör eller tömmer det tidigare tilldelade minnesutrymmet. |
Låt oss diskutera ovanstående funktioner med deras applikation
C malloc () Funktion
Funktionen C malloc () står för minnesallokering. Det är en funktion som används för att allokera ett minnesblock dynamiskt. Den reserverar minnesutrymme av angiven storlek och returnerar nollpekaren som pekar till minnesplatsen. Pekaren som returneras är vanligtvis ogiltig. Det betyder att vi kan tilldela C malloc () -funktion till valfri pekare.
Syntax för malloc () Funktion:
ptr = (cast_type *) malloc (byte_size);
Här,
- ptr är en pekare av cast_type.
- Funktionen C malloc () returnerar en pekare till det tilldelade minnet för byte_size.
Exempel på malloc ():
Example: ptr = (int *) malloc (50)
När detta uttalande har utförts reserveras ett minnesutrymme på 50 byte. Adressen till den första byten med reserverat utrymme tilldelas pekaren ptr av typen int.
Tänk på ett annat exempel:
#includeint 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));}}
Produktion:
Value of the 6th integer is 480
- Lägg märke till att sizeof (* ptr) användes istället för sizeof (int) för att göra koden mer robust när * ptr-deklarationen skrivs ut till en annan datatyp senare.
- Tilldelningen kan misslyckas om minnet inte är tillräckligt. I det här fallet returnerar den en NULL-pekare. Så du bör inkludera kod för att söka efter en NULL-pekare.
- Tänk på att det tilldelade minnet är sammanhängande och att det kan behandlas som en matris. Vi kan använda pekarens aritmetik för att komma åt arrayelementen istället för att använda parenteser []. Vi rekommenderar att du använder + för att hänvisa till arrayelement eftersom användning av inkrementering ++ eller + = ändrar adressen som lagras av pekaren.
Malloc () -funktionen kan också användas med teckendatatypen liksom komplexa datatyper som strukturer.
Den fria () funktionen
Minne för variabler omlokaliseras automatiskt vid sammanställningstid. I dynamisk minnestilldelning måste du omplacera minnet uttryckligen. Om du inte gör det kan du få ett minnesfel.
Den gratis () -funktionen kallas för att frigöra / avdela minne i C. Genom att frigöra minne i ditt program gör du mer tillgängligt för användning senare.
Till exempel:
#includeint 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);}
Produktion
Value of the 2nd integer is 50
C calloc () -funktion
Funktionen C calloc () står för sammanhängande allokering. Denna funktion används för att allokera flera minnesblock. Det är en dynamisk minnesallokeringsfunktion som används för att allokera minnet till komplexa datastrukturer såsom matriser och strukturer.
Malloc () -funktionen används för att allokera ett enda minnesutrymme medan calloc () i C används för att allokera flera minnesutrymme. Varje block som tilldelats av calloc () -funktionen har samma storlek.
Syntax för calloc () Funktion:
ptr = (cast_type *) calloc (n, size);
- Ovanstående uttalande används för att allokera n minnesblock av samma storlek.
- Efter att minnesutrymmet har tilldelats initialiseras alla byte till noll.
- Pekaren som för närvarande är vid den första byten i det tilldelade minnesutrymmet returneras.
Närhelst det uppstår ett fel vid tilldelning av minnesutrymme, såsom minnesbrist, returneras en nollpekare.
Exempel på calloc ():
Programmet nedan beräknar summan av en aritmetisk sekvens.
#includeint 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 (): Viktiga skillnader
Följande är nyckelskillnaden mellan malloc () Vs calloc () i C:
Calloc () -funktionen är i allmänhet mer lämplig och effektiv än malloc () -funktionen. Medan båda funktionerna används för att allokera minnesutrymme kan calloc () allokera flera block åt gången. Du behöver inte begära ett minnesblock varje gång. Calloc () -funktionen används i komplexa datastrukturer som kräver större minnesutrymme.
Minnesblocket tilldelat av en calloc () i C initialiseras alltid till noll medan det i funktion malloc () i C innehåller alltid ett skräpvärde.
C realloc () -funktion
Med C realloc () -funktionen kan du lägga till mer minnesstorlek till redan tilldelat minne. Det expanderar det aktuella blocket medan det ursprungliga innehållet lämnas som det är. realloc () i C står för omfördelning av minne.
realloc () kan också användas för att minska storleken på det tidigare tilldelade minnet.
Syntax för realloc () Funktion:
ptr = realloc (ptr,newsize);
Ovanstående uttalande tilldelar ett nytt minnesutrymme med en viss storlek i variabeln nyhetsstorlek. Efter att funktionen har utförts kommer pekaren att returneras till den första byten i minnesblocket. Den nya storleken kan vara större eller mindre än föregående minne. Vi kan inte vara säkra på att om det nyligen tilldelade blocket pekar på samma plats som det tidigare minnesblocket. Denna funktion kopierar alla tidigare data i den nya regionen. Det ser till att data förblir säkra.
Exempel på realloc ():
#includeint 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;}
När realloc () i C resulterar i en misslyckad operation returnerar den en nollpekare och tidigare data frigörs också.
Dynamiska matriser i C
En dynamisk matris i C gör att antalet element kan växa efter behov. C Dynamic array används ofta i datavetenskapliga algoritmer.
I följande program har vi skapat och ändrat storlek på en dynamisk matris i C
#includeint 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å skärmen:
arr_dynamic[0]=0arr_dynamic[1]=1After reallocarr_dynamic[0]=0arr_dynamic[1]=1arr_dynamic[2]=2arr_dynamic[3]=3
Sammanfattning
- Vi kan dynamiskt hantera minne genom att skapa minnesblock efter behov i högen
- I C Dynamic Memory Allocation allokeras minne vid en körtid.
- Dynamisk minnesallokering gör det möjligt att manipulera strängar och matriser vars storlek är flexibel och kan ändras när som helst i ditt program.
- Det krävs när du inte har någon aning om hur mycket minne en viss struktur kommer att uppta.
- Malloc () i C är en dynamisk minnesallokeringsfunktion som står för minnesallokering som blockerar minne med den specifika storleken initierad till ett skräpvärde
- Calloc () i C är en angränsande minnesallokeringsfunktion som allokerar flera minnesblock åt gången initialiserat till 0
- Realloc () i C används för att omfördela minne enligt den angivna storleken.
- Free () -funktionen används för att rensa det dynamiskt tilldelade minnet.