malloc() Funktion i C-bibliotek med EXEMPEL

Vad är malloc i C?

Funktionen malloc() står för minnesallokering. Det är en funktion som används för att tilldela ett minnesblock dynamiskt. Den reserverar minnesutrymme av specificerad storlek och returnerar nollpekaren som pekar till minnesplatsen. Pekaren som returneras är vanligtvis av typen void. Det betyder att vi kan tilldela malloc-funktion till vilken pekare som helst.

syntax

ptr = (cast_type *) malloc (byte_size);

Här,

• ptr är en pekare av cast_type.
• Malloc-funktionen returnerar en pekare till det tilldelade minnet av byte_size.

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

När denna sats exekveras framgångsrikt, reserveras ett minnesutrymme på 50 byte. Adressen för den första byten av reserverat utrymme tilldelas pekaren ptr av typen int.

Tänk på ett annat exempel på malloc-implementering:

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

Produktion:

Value of the 6th integer is 480

Observera att sizeof(*ptr) användes istället för sizeof(int) för att göra koden mer robust när *ptr-deklarationen typecastas till en annan datatyp senare.

Tilldelningen kan misslyckas om minnet inte räcker till. I det här fallet returnerar den en NULL-pekare. Så du bör inkludera kod för att leta efter en NULL-pekare.

Tänk på att det allokerade minnet är sammanhängande och kan behandlas som en array. Vi kan använda pekare aritmetik för att komma åt arrayelementen istället för att använda parenteser []. Vi rekommenderar att använda + för att referera till arrayelement eftersom användning av inkrementering ++ eller += ändrar adressen som lagras av pekaren.

Malloc-funktionen kan också användas med teckendatatypen såväl som komplexa datatyper som strukturer.

Varför använda malloc() i C?

Statiska arrayer och vanliga variabler fixerar sin storlek när programmet kompileras, vilket slösar utrymme när kravet visar sig vara mindre och misslyckas direkt när det visar sig vara större. malloc() löser detta genom att begära minne vid körning, så att ett program kan anpassa storleken på en buffert till den exakta mängd data det tar emot. Denna flexibilitet vid körning är kärnan i dynamisk minnesallokering i C.

Dynamisk allokering med malloc() är rätt val i flera vanliga situationer:

• Mängden indata är okänd förrän programmet körs, till exempel när en fil eller en användarlevererad lista läses.
• Stora block behövs som skulle överflöda den begränsade stacken, eftersom malloc() hämtar data från den mycket större heapen.
• Data måste överleva den funktion som skapade den, eftersom heap-minnet kvarstår tills det explicit släpps.
• Strukturer och arrayer måste växa eller krympa medan programmet körs.

Eftersom det reserverade blocket lämnas tillbaka som en pekare kan det skickas mellan funktioner billigt utan att kopiera underliggande data.

Hur man frigör minne allokerat av malloc()

Minne som reserveras av malloc() finns på heapen och frigörs aldrig automatiskt. När ett program fortsätter att allokera utan att frigöra, förbrukar det långsamt allt tillgängligt minne, en defekt som kallas minnesläcka. Funktionen free() returnerar ett färdigt block till systemet så att utrymmet kan återanvändas.

Funktionen free() tar ett enda argument, pekaren som malloc() returnerade, och släpper hela blocket på en gång:

int *ptr;
ptr = malloc(10 * sizeof(int));
if (ptr != NULL) {
    /* use the allocated memory here */
    free(ptr);   /* release the block */
    ptr = NULL;  /* avoid a dangling pointer */
}

Följ dessa regler för att hantera dynamiskt minne på ett säkert sätt:

• Anropa free() exakt en gång för varje lyckad malloc(); att frigöra samma block två gånger orsakar odefinierat beteende.
• Sätt pekaren till NULL efter frigöring så att den inte kan återanvändas som en dinglande pekare.
• Frigör aldrig en pekare som malloc() inte returnerade, inklusive en som förskjutits av pekararitmetik.
• Matcha varje allokering med en matchande release innan pekaren går utanför räckvidden.

keeping Balanserad allokering och frigöring är kärndisciplinen för manuell minneshantering i C, och det förhindrar både läckor och krascher orsakade av återanvändning av frigjort minne.

malloc() vs calloc(): Viktiga skillnader

malloc() och calloc() båda reserverar heap-minne, men de skiljer sig åt i sina argument och i hur de behandlar det nya blocket. malloc() tar ett argument, det totala antalet byte, och lämnar innehållet oinitierat, så blocket innehåller oförutsägbara skräpvärden tills programmet skriver till det. calloc() tar två argument, antalet element och storleken på varje, och rensar varje byte till noll innan pekaren returneras.

De praktiska skillnaderna kan handla om tre punkter:

• Initialisering: calloc() nollställer minnet, medan malloc() inte gör det, vilket gör malloc() något snabbare när värdena ändå kommer att skrivas över.
• Argument: du skriver malloc(n * size) men calloc(n, size) för att reservera samma array.
• Användningsfall: välj calloc() när ett rent, nollställt block är viktigt, och malloc() när hastighet föredras och initialisering hanteras manuellt.

Båda funktionerna deklareras i stdlib.h, båda returnerar en void-pekare eller NULL vid fel, och båda lämnar tillbaka sitt minne med samma free()-funktion.

Vanliga frågor