C Academy · Les

malloc en free

Op de heap alloceren

Les 1 van 413 stappen

malloc en free 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.

De heap

Tot nu toe leefden variabelen op de stack met een vaste levensduur. Met de heap kun je tijdens runtime geheugen aanvragen en dit zo lang behouden als je nodig hebt.

Je beheert heapgeheugen zelf met functies uit <stdlib.h>.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 99;
    printf("%d\n", *p);
    free(p);
    return 0;
}

malloc aanroepen

malloc(size) reserveert size bytes en retourneert een pointer ernaartoe, of NULL als de bewerking mislukt.

Het geheugen is niet geïnitialiseerd: de inhoud is onbepaald.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 7;
    printf("value = %d\n", *p);
    free(p);
    return 0;
}

De grootte bepalen met sizeof

Bepaal de grootte van toewijzingen altijd met sizeof, zodat de code op elk platform correct is.

Met sizeof(*p) koppel je de grootte automatisch aan het type van de pointer.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    double *p = malloc(sizeof(*p));
    *p = 3.14;
    printf("%f\n", *p);
    free(p);
    return 0;
}

Controleer altijd op NULL

Als de geheugentoewijzing mislukt, retourneert malloc NULL. Het derefereren daarvan laat het programma crashen.

Controleer het resultaat voordat je het gebruikt.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    if (p == NULL) {
        printf("allocation failed\n");
        return 1;
    }
    *p = 5;
    printf("ok: %d\n", *p);
    free(p);
    return 0;
}

Een array toewijzen

Om veel elementen op te slaan, vermenigvuldig je de grootte van een element met het aantal elementen.

malloc(n * sizeof(int)) maakt ruimte voor n integers.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n = 5;
    int *arr = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) arr[i] = i * i;
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    free(arr);
    return 0;
}

Heaparrays gebruiken pointerindexering

Je benadert een heaparray via zijn pointer met de bekende syntaxis arr[i], die gelijk is aan *(arr + i).

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *arr = malloc(3 * sizeof(int));
    arr[0] = 10;
    *(arr + 1) = 20;
    arr[2] = 30;
    printf("%d %d %d\n", arr[0], arr[1], arr[2]);
    free(arr);
    return 0;
}

Geheugen vrijgeven

free(p) geeft het blok terug aan de geheugentoewijzer. Daarna mag je p niet meer gebruiken om dat geheugen te benaderen.

Elke geslaagde malloc heeft een bijbehorende free nodig.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    char *buf = malloc(16);
    if (buf) {
        buf[0] = 'A';
        printf("%c\n", buf[0]);
        free(buf);
    }
    return 0;
}

free(NULL) is veilig

free aanroepen met een NULL-pointer doet niets en is volledig toegestaan.

Dit vereenvoudigt opruimcode die kan worden uitgevoerd voordat de geheugentoewijzing slaagt.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = NULL;
    free(p);
    printf("free(NULL) was safe\n");
    return 0;
}

Heapgeheugen retourneren

In tegenstelling tot stackvariabelen blijft heapgeheugen bestaan nadat de functie retourneert. Daardoor kan een functie een buffer toewijzen en teruggeven.

#include <stdio.h>
#include <stdlib.h>

int *make_range(int n) {
    int *a = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) a[i] = i;
    return a;
}

int main(void) {
    int *r = make_range(4);
    printf("%d %d\n", r[0], r[3]);
    free(r);
    return 0;
}

Cast malloc niet in C

In C retourneert malloc een void *, die automatisch naar elk pointertype wordt geconverteerd.

Een cast is overbodig en kan verbergen dat <stdlib.h> ontbreekt.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    long *p = malloc(sizeof(long));
    *p = 1234567L;
    printf("%ld\n", *p);
    free(p);
    return 0;
}

Geef niet twee keer vrij

free twee keer aanroepen met dezelfde pointer is ongedefinieerd gedrag en kan de heap beschadigen.

Stel de pointer na het vrijgeven in op NULL om onbedoeld hergebruik onschadelijk te maken.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 1;
    free(p);
    p = NULL;
    free(p);
    printf("no double free\n");
    return 0;
}

Korte controle

Test je kennis van malloc en free.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt de basis van heaptoewijzing geleerd:

malloc(size) reserveert niet-geïnitialiseerde bytes en retourneert NULL als de bewerking mislukt.
Controleer altijd het resultaat en bepaal de grootte met sizeof.
free(p) geeft geheugen vrij; elke malloc heeft één free nodig.
free(NULL) is veilig; dubbel vrijgeven is ongedefinieerd.

Gratis beginnen

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

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “malloc en free” gratis?

Ja — de volledige tekst van “malloc en free” 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 “malloc en free”?

Op de heap alloceren 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 “malloc en free”?

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.

Alle lessen in deze cursus

← Terug naar C Academy