malloc() Functie in C-bibliotheek met VOORBEELD

Wat is malloc in C?

De malloc()-functie 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 malloc-functie aan elke aanwijzer kunnen toewijzen.

Syntaxis

ptr = (cast_type *) malloc (byte_size);

Hier

• ptr is een pointer van cast_type.
• De malloc-functie retourneert een verwijzing naar het toegewezen geheugen van byte_size.

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 van malloc-implementatie:

#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

Merk op dat sizeof(*ptr) is gebruikt in plaats van sizeof(int) om de code robuuster te maken wanneer de *ptr-declaratie later wordt gecast naar een ander gegevenstype.

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.

Houd er rekening mee dat het toegewezen geheugen aaneengesloten is en als een array kan worden behandeld. We kunnen gebruikmaken van wijzer Gebruik rekenkundige bewerkingen 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 verhogen met ++ of += het adres wijzigt dat door de pointer wordt opgeslagen.

De Malloc-functie kan ook worden gebruikt met het gegevenstype karakter en complexe gegevenstypen zoals structuren.

Waarom malloc() gebruiken in C?

Statische arrays en gewone variabelen hebben een vaste grootte tijdens het compileren van het programma. Dit leidt tot verspilling van geheugen wanneer de benodigde hoeveelheid kleiner blijkt te zijn en tot een volledige mislukking wanneer deze groter blijkt te zijn. `malloc()` lost dit op door geheugen aan te vragen tijdens de uitvoering, waardoor een programma een buffer precies kan aanpassen aan de hoeveelheid gegevens die het ontvangt. Deze flexibiliteit tijdens de uitvoering is de kern van de functionaliteit. dynamische geheugentoewijzing in C.

Dynamische geheugenallocatie met malloc() is in diverse veelvoorkomende situaties de juiste keuze:

• De hoeveelheid invoer is pas bekend wanneer het programma wordt uitgevoerd, bijvoorbeeld bij het lezen van een bestand of een door de gebruiker aangeleverde lijst.
• Er zijn grote blokken nodig die de beperkte stack zouden overschrijden, aangezien malloc() geheugen uit de veel grotere heap haalt.
• Gegevens moeten langer bestaan ​​dan de functie die ze heeft aangemaakt, omdat het heapgeheugen blijft bestaan ​​totdat het expliciet wordt vrijgegeven.
• Structuren en arrays moeten tijdens de uitvoering van het programma kunnen groeien of krimpen.

Omdat het gereserveerde blok als een pointer wordt teruggegeven, kan het goedkoop tussen functies worden doorgegeven zonder de onderliggende gegevens te kopiëren.

Hoe geef ik geheugen vrij dat is toegewezen met malloc()?

Geheugen dat gereserveerd wordt met malloc() bevindt zich op de heap en wordt nooit automatisch vrijgegeven. Wanneer een programma continu geheugen toewijst zonder het vrij te geven, verbruikt het langzaam al het beschikbare geheugen. Dit defect staat bekend als een geheugenlek. De functie free() geeft een voltooid blok terug aan het systeem, zodat de ruimte opnieuw gebruikt kan worden.

De functie free() neemt één argument, de pointer die malloc() heeft geretourneerd, en geeft het hele blok in één keer vrij:

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 */
}

Volg deze regels om dynamisch geheugen veilig te beheren:

• Roep free() precies één keer aan voor elke succesvolle malloc(); het tweemaal vrijgeven van hetzelfde blok leidt tot onvoorspelbaar gedrag.
• Stel de pointer na het vrijgeven in op NULL, zodat deze niet opnieuw als zwevende pointer kan worden gebruikt.
• Geef nooit een pointer vrij die niet door malloc() is geretourneerd, inclusief een pointer die is verschoven door pointer-aritmetiek.
• Zorg ervoor dat elke toewijzing wordt gekoppeld aan een overeenkomstige vrijgave voordat de pointer buiten het bereik valt.

Keeping Het evenwichtig toewijzen en vrijgeven van geheugen is de kern van handmatig geheugenbeheer in C en voorkomt zowel geheugenlekken als crashes die worden veroorzaakt door het hergebruik van vrijgegeven geheugen.

malloc() versus calloc(): Belangrijkste verschillen

malloc() en calloc() Beide functies reserveren heapgeheugen, maar ze verschillen in hun argumenten en in hoe ze het nieuwe blok behandelen. `malloc()` neemt één argument, het totale aantal bytes, en laat de inhoud ongeïnitialiseerd, waardoor het blok onvoorspelbare willekeurige waarden bevat totdat het programma erin schrijft. `calloc()` neemt twee argumenten, het aantal elementen en de grootte van elk element, en wist elke byte naar nul voordat de pointer wordt geretourneerd.

De praktische verschillen komen neer op drie punten:

• Initialisatie: calloc() vult het geheugen met nullen, terwijl malloc() dat niet doet. Daardoor is malloc() iets sneller als de waarden toch overschreven worden.
• Argumenten: je schrijft malloc(n * size), maar calloc(n, size) om dezelfde array te reserveren.
• Gebruiksscenario: kies calloc() wanneer een schoon, met nullen gevuld blok belangrijk is, en malloc() wanneer snelheid de voorkeur heeft en de initialisatie handmatig wordt afgehandeld.

Beide functies zijn gedeclareerd in stdlib.h, beide retourneren een void-pointer of NULL bij een fout, en beide geven hun geheugen terug met dezelfde free()-functie.

Veelgestelde vragen