C Academy · Les

Een array toewijzen

Reserveer heapgeheugen.

Les 1 van 413 stappen

Een array toewijzen 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.

Waarom dynamische arrays?

Een gewone array heeft een vaste grootte die tijdens het compileren wordt ingesteld. Vaak weet je echter pas tijdens het uitvoeren van het programma hoeveel elementen je nodig hebt.

Dynamische arrays lossen dit op: je vraagt het besturingssysteem tijdens runtime om een geheugenblok met malloc en bepaalt de grootte met een variabele.

Kennismaken met malloc

malloc (geheugen toewijzen) staat in <stdlib.h>. Je geeft het een aantal bytes mee en het retourneert een pointer naar dat blok, of NULL als het mislukt.

Het geheugen komt uit de heap en blijft bestaan totdat je het vrijgeeft.

int *p = malloc(10 * sizeof(int));

Grootte bepalen met sizeof

Leg nooit aantallen bytes hard vast. Gebruik sizeof, zodat je code op verschillende platforms correct blijft werken.

Vermenigvuldig voor ruimte voor n gehele getallen n met sizeof(int). Een gebruikelijk idioom is n * sizeof(*p), dat het eigen type van de pointer gebruikt.

int *p = malloc(n * sizeof(*p));

Controleer altijd op NULL

Als het systeem geen geheugen meer heeft, retourneert malloc NULL. Een NULL-pointer derefereren laat je programma crashen.

Controleer het resultaat voordat je het gebruikt. Deze ene gewoonte voorkomt veel moeilijk te vinden fouten.

int *p = malloc(n * sizeof(*p));
if (p == NULL) {
    fprintf(stderr, "out of memory\n");
    return 1;
}

Een volledige geheugentoewijzing

Hier staat een volledig programma dat ruimte voor 5 gehele getallen reserveert, ze invult en afdrukt.

Let op de symmetrie: malloc aan het begin en free aan het einde.

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

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

malloc maakt niet nul

Geheugen van malloc is niet geïnitialiseerd: het bevat willekeurige resten van wat er eerder stond.

Als je het leest voordat je het hebt beschreven, krijg je onvoorspelbare waarden. Wijs altijd aan elk element een waarde toe voordat je het leest.

int *a = malloc(3 * sizeof(*a));
/* a[0], a[1], a[2] hold garbage here */
a[0] = 10;

calloc maakt voor jou alles nul

calloc(count, size) reserveert ruimte voor count elementen van size bytes en zet elke byte op nul.

Gebruik dit wanneer je een schone, met nullen gevulde array wilt. Het beschermt ook tegen overloop bij de vermenigvuldiging.

int *a = calloc(5, sizeof(*a));
/* every element is now 0 */

calloc in actie

Dit programma gebruikt calloc en bevestigt dat de array met nullen begint voordat we die wijzigen.

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

int main(void) {
    int n = 4;
    int *a = calloc(n, sizeof(*a));
    if (!a) return 1;
    for (int i = 0; i < n; i++) printf("%d\n", a[i]);
    free(a);
    return 0;
}

Het blok indexeren

Een pointer naar een heapblok gedraagt zich net als een arraynaam. Je kunt a[i] gebruiken om elk element van 0 tot en met n-1 te lezen en te schrijven.

Onder de motorkap is a[i] hetzelfde als *(a + i).

int *a = malloc(3 * sizeof(*a));
a[0] = 1;
*(a + 1) = 2;   /* same as a[1] = 2 */
a[2] = 3;

Let op de grenzen

Als je n elementen reserveert, zijn de geldige indexen 0 tot en met n-1. Schrijven naar a[n] is ongedefinieerd gedrag.

C controleert de grenzen niet voor je, dus een fout van één positie kan het geheugen ongemerkt beschadigen.

int *a = malloc(3 * sizeof(*a));
a[2] = 99;   /* OK, last valid index */
/* a[3] = 0;  BUG: out of bounds */

De grootte tijdens runtime lezen

Daar zit de echte kracht: de grootte kan afkomstig zijn van invoer, een bestand of een berekening. Dezelfde code reserveert ruimte voor 2 of 2 miljoen elementen.

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

int main(void) {
    int n = 6;            /* could be scanf'd */
    long *a = malloc(n * sizeof(*a));
    if (!a) return 1;
    long sum = 0;
    for (int i = 0; i < n; i++) { a[i] = i + 1; sum += a[i]; }
    printf("%ld\n", sum);
    free(a);
    return 0;
}

Korte controle

Toets je begrip van geheugentoewijzing.

Beantwoord dit in de interactieve les

Samenvatting

Je reserveert een dynamische array met malloc(n * sizeof(*p)) of een met nullen gevulde array met calloc(n, sizeof(*p)).

Controleer altijd op NULL, onthoud dat malloc willekeurige inhoud laat staan, indexeer van 0 tot en met n-1 en koppel elke geheugentoewijzing aan een free. Hierna leer je een blok groter te maken zonder de gegevens kwijt te raken.

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 “Een array toewijzen” gratis?

Ja — de volledige tekst van “Een array toewijzen” 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 “Een array toewijzen”?

Reserveer heapgeheugen. 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 “Een array toewijzen”?

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