Hoe malloc werkt
De heap en free lists.
Hoe malloc werkt is een gratis C Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C Academy bevat in totaal 4 lessen.
Wat malloc echt doet
Wanneer je malloc(n) aanroept, geeft de C-bibliotheek je een verwijzing naar minstens n bruikbare bytes. De heap is echter slechts een gebied in het procesgeheugen dat de geheugentoewijzer namens jou beheert.
De taak van de geheugentoewijzer is administratie: bijhouden welke bytes in gebruik zijn, welke vrij zijn en hoe vrijgegeven geheugen efficiënt kan worden hergebruikt.
De heap komt van het besturingssysteem
De geheugentoewijzer maakt geen geheugen uit het niets. Hij vraagt het besturingssysteem om grote stukken via systeemaanroepen zoals brk/sbrk of mmap.
Vervolgens verdeelt hij die stukken in kleinere blokken voor je aanroepen van malloc. Het besturingssysteem om geheugen vragen is duur, dus geheugentoewijzers vragen geheugen in bulk en recyclen het.
/* Conceptual: grow the heap by 4096 bytes */
void *base = sbrk(4096);
if (base == (void *)-1) {
/* out of memory */
}sbrk en de programmagrens
sbrk(n) verplaatst de "program break" met n bytes omhoog en retourneert de vorige grens. Het nieuw vrijgekomen gebied wordt beschikbare heapruimte.
Dit is lineair en eenvoudig, maar geheugen in het midden kan niet gemakkelijk worden teruggegeven. Moderne geheugentoewijzers gebruiken voor grote aanvragen liever mmap.
void *prev_break = sbrk(0); /* current break */
sbrk(1024); /* grow by 1 KB */
/* prev_break now points to fresh memory */Metagegevens van blokken
Voor elke geheugentoewijzing slaat de geheugentoewijzer een kleine kop direct naast de gegevens op: de grootte en of het blok vrij is. Dankzij deze kop kan free werken met alleen de gegevensverwijzing die je teruggeeft.
De verwijzing die je van malloc ontvangt wijst na de kop, zodat de metagegevens voor jou verborgen blijven.
typedef struct block {
size_t size;
int free;
struct block *next;
} block_t;Verwijzing direct na de kop
Een veelgebruikte truc is verwijzingsrekenen: de gebruikersverwijzing is header + 1. Bij een gebruikersverwijzing staat de kop één block_t ervoor.
Zo kan free(p) de grootte van het toegewezen blok terugvinden zonder dat je die zelf hoeft mee te geven.
block_t *hdr = (block_t *)user_ptr - 1;
printf("block size = %zu\n", hdr->size);Demonstratie van een kleine kopindeling
Laten we een kop over een statische buffer leggen en deze weer uitlezen. Zo zie je hoe een echte geheugentoewijzer een gebied opsplitst in een kop en een gegevensgedeelte.
Er worden geen aanroepen naar het besturingssysteem gedaan, dus dit werkt overal.
#include <stdio.h>
#include <stddef.h>
typedef struct { size_t size; int free; } block_t;
static char buffer[256];
int main(void) {
block_t *h = (block_t *)buffer;
h->size = 64;
h->free = 0;
void *payload = (char *)buffer + sizeof(block_t);
printf("header bytes = %zu\n", sizeof(block_t));
printf("payload offset = %ld\n", (long)((char *)payload - buffer));
printf("size field = %zu\n", h->size);
return 0;
}Het idee van de vrije lijst
Veel geheugentoewijzers verbinden vrije blokken tot een gekoppelde lijst. Wanneer je malloc aanroept, doorloopt de geheugentoewijzer deze lijst op zoek naar een blok dat groot genoeg is.
Wanneer je free aanroept, wordt het blok als vrij gemarkeerd en teruggezet in de lijst voor later hergebruik. Zo is geen nieuwe aanvraag bij het besturingssysteem nodig.
block_t *find_free(block_t *head, size_t size) {
block_t *b = head;
while (b && !(b->free && b->size >= size))
b = b->next;
return b;
}Wat free moet doen
free(p) vindt de kop voor p, markeert deze als vrij en voegt het blok idealiter samen met aangrenzende vrije blokken (coalescentie) om fragmentatie tegen te gaan.
Als je tweemaal free aanroept voor dezelfde verwijzing of een verwijzing vrijgeeft die niet naar de heap wijst, ontstaat ongedefinieerd gedrag omdat de metagegevens beschadigd raken.
void my_free(void *p) {
if (!p) return;
block_t *hdr = (block_t *)p - 1;
hdr->free = 1;
/* real allocators coalesce neighbors here */
}Fragmentatie
Na verloop van tijd ontstaan er gaten doordat blokken van verschillende grootten worden vrijgegeven en toegewezen. Externe fragmentatie betekent dat er vrij geheugen is, maar dat dit verspreid ligt in stukken die te klein zijn voor een aanvraag.
Interne fragmentatie is verspilde ruimte binnen een blok dat groter is dan nodig, vaak door uitlijning of afronding.
Vereisten voor uitlijning
malloc moet geheugen teruggeven dat voor elk type correct is uitgelijnd. Op de meeste 64-bitsystemen betekent dit een uitlijning op 16 bytes, waarmee aan max_align_t wordt voldaan.
Niet-uitgelijnde verwijzingen kunnen op sommige CPU's een crash veroorzaken of op andere de toegang vertragen. Daarom ronden geheugentoewijzers gegevensblokken altijd af naar een uitlijningsgrens.
#include <stdalign.h>
/* alignof(max_align_t) is the strictest required alignment */
size_t a = alignof(max_align_t);Alles samenbrengen
Een minimale geheugentoewijzer heeft daarom het volgende nodig: een geheugenbron (een statische buffer, sbrk of mmap), koppen per blok, een strategie om vrije ruimte te vinden en verwerking van uitlijning.
In de volgende lessen bouwen we deze onderdelen: eerst een bump-geheugentoewijzer, daarna vrije lijsten en vervolgens uitlijning en het splitsen van blokken.
/* The four pillars of a custom allocator */
/* 1. memory source 2. block headers */
/* 3. free-block search 4. alignment */Korte controle
Test je begrip van de interne werking van geheugentoewijzers.
Samenvatting
malloc beheert een heap die via sbrk of mmap van het besturingssysteem is verkregen en deze opdeelt in blokken met verborgen koppen die de grootte en de vrije status bijhouden.
Met vrije lijsten kan geheugen worden hergebruikt, uitlijning zorgt ervoor dat elk type goed werkt en fragmentatie is de belangrijkste uitdaging. Deze ideeën vormen de basis voor de geheugentoewijzer die we hierna bouwen.
Leer C met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 39
- Lessen
- 144
Veelgestelde vragen
Is de les “Hoe malloc werkt” gratis?
Ja — de volledige tekst van “Hoe malloc werkt” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C Academy bevat in totaal 4 lessen.
Wat leer ik in “Hoe malloc werkt”?
De heap en free lists. Je oefent met C Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met C Academy te beginnen?
Ervaring vooraf is niet nodig. C Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Hoe malloc werkt”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over C Academy?
Ja. Elke les over C Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.