Dynamische geheugentoewijzing in C

Deze gids begeleidt je door dynamische geheugentoewijzing in C met de standaardbibliotheek-functies malloc(), calloc(), realloc() en free(), met duidelijke voorbeelden en best-practice tips.

Waarom dynamische toewijzing gebruiken?

Statische arrays hebben een vaste grootte die bij compile-tijd wordt gedeclareerd, wat kan leiden tot verspilde ruimte of onvoldoende capaciteit tijdens runtime. Dynamische toewijzing laat je precies het aantal geheugen aanvragen dat je nodig hebt terwijl het programma draait.

Alle vier de functies zijn gedefinieerd in de <stdlib.h> header en bieden een gecontroleerde manier om heap-geheugen te beheren.

malloc() – Een blok bytes toewijzen

De naam malloc staat voor "memory allocation". Het reserveert een aaneengesloten blok geheugen van de opgegeven grootte (in bytes) en retourneert een pointer van type void * die gecast kan worden naar elk ander pointer-type.

Syntaxis

ptr = malloc(grootte_in_bytes); // cast naar gewenst type indien nodig

Voorbeeld

float *ptr = malloc(100 * sizeof(float)); // 400 bytes op de meeste systemen

Hier wijst ptr naar de eerste byte van een 400-byte blok. Als de aanvraag mislukt, retourneert malloc NULL. Het is aanbevolen om onnodige casts in C te vermijden; de compiler kan het type afleiden wanneer je het resultaat toewijst aan een getypte pointer.

calloc() – Toewijzen en nul-initialiseren

calloc staat voor "contiguous allocation". In tegenstelling tot malloc, initialiseert het elke bit van het toegewezen blok op nul, wat het veilig maakt voor numerieke typen en pointers.

Syntaxis

ptr = calloc(aantal_elementen, grootte_van_elk_element);

Voorbeeld

float *ptr = calloc(25, sizeof(float)); // 25 genulde float-elementen

De geretourneerde pointer is NULL als de toewijzing mislukt.

free() – Toegewezen geheugen vrijgeven

Geheugen verkregen met malloc of calloc blijft bestaan tot je het expliciet vrijgeeft. free() dealloceert het blok en geeft het geheugen terug aan de heap voor toekomstig hergebruik.

Syntaxis

free(ptr);

Het aanroepen van free op een NULL-pointer is veilig en doet niets.

Voorbeeld 1: malloc() en free() gebruiken

#include <stdio.h>
#include <stdlib.h>
int main(void) {
    int n, i, *ptr, sum = 0;
    printf("Voer aantal elementen in: ");
    scanf("%d", &n);
    ptr = malloc(n * sizeof(int));
    if (!ptr) {
        fprintf(stderr, "Fout: geheugen niet toegewezen.\n");
        return EXIT_FAILURE;
    }
    printf("Voer elementen in: ");
    for (i = 0; i < n; ++i) {
        scanf("%d", ptr + i);
        sum += *(ptr + i);
    }
    printf("Som = %d\n", sum);
    free(ptr);
    return EXIT_SUCCESS;
}

Output

Voer aantal elementen in: 3
Voer elementen in: 100 20 36
Som = 156

Voorbeeld 2: calloc() en free() gebruiken

#include <stdio.h>
#include <stdlib.h>
int main(void) {
    int n, i, *ptr, sum = 0;
    printf("Voer aantal elementen in: ");
    scanf("%d", &n);
    ptr = calloc(n, sizeof(int));
    if (!ptr) {
        fprintf(stderr, "Fout: geheugen niet toegewezen.\n");
        return EXIT_FAILURE;
    }
    printf("Voer elementen in: ");
    for (i = 0; i < n; ++i) {
        scanf("%d", ptr + i);
        sum += *(ptr + i);
    }
    printf("Som = %d\n", sum);
    free(ptr);
    return EXIT_SUCCESS;
}

Output

Voer aantal elementen in: 3
Voer elementen in: 100 20 36
Som = 156

realloc() – Een bestaande toewijzing vergroten/kleinen

Als je ontdekt dat je huidige toewijzing te klein of groter dan nodig is, past realloc() de grootte aan terwijl de bestaande data behouden blijft (tot de nieuwe grootte).

Syntaxis

ptr = realloc(ptr, nieuwe_grootte_in_bytes);

Het retourneert een pointer naar het hertoegewezen blok of NULL bij falen. Om geheugenlekken te voorkomen, bewaar het resultaat eerst in een tijdelijke pointer.

Voorbeeld 3: realloc() gebruiken

#include <stdio.h>
#include <stdlib.h>
int main(void) {
    int *ptr, i, n1, n2;
    printf("Voer initiële grootte in: ");
    scanf("%d", &n1);
    ptr = malloc(n1 * sizeof(int));
    if (!ptr) {
        fprintf(stderr, "Toewijzing mislukt.\n");
        return EXIT_FAILURE;
    }
    printf("Adressen voor hertoewijzing:\n");
    for (i = 0; i < n1; ++i) printf("%p\n", ptr + i);
    printf("\nVoer nieuwe grootte in: ");
    scanf("%d", &n2);
    int *tmp = realloc(ptr, n2 * sizeof(int));
    if (!tmp) {
        fprintf(stderr, "Hertoewijzing mislukt.\n");
        free(ptr);
        return EXIT_FAILURE;
    }
    ptr = tmp;
    printf("Adressen na hertoewijzing:\n");
    for (i = 0; i < n2; ++i) printf("%p\n", ptr + i);
    free(ptr);
    return EXIT_SUCCESS;
}

Typische Output

Voer initiële grootte in: 2
Adressen voor hertoewijzing:
0x7ffc12345670
0x7ffc12345674
Voer nieuwe grootte in: 4
Adressen na hertoewijzing:
0x7ffc12345670
0x7ffc12345674
0x7ffc12345678
0x7ffc1234567c

Door deze vier functies onder de knie te krijgen en correcte foutafhandeling toe te passen, kun je heap-geheugen veilig en efficiënt beheren in elke C-applicatie.