Groeien met realloc
Pas de grootte van een dynamische array aan.
Groeien met realloc is een gratis C Academy-les op CoddyKit. Dit is les 2 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.
Wanneer één malloc niet genoeg is
Soms reserveer je ruimte voor een array, vul je die en ontdek je daarna dat je meer ruimte nodig hebt. Je kunt niet zomaar voorbij het einde schrijven.
Met realloc kun je een bestaand heapblok groter of kleiner maken, waarbij de gegevens die er al stonden behouden blijven.
De signatuur van realloc
realloc(ptr, new_bytes) neemt de oude pointer en de nieuwe totale grootte in bytes.
Het retourneert een pointer naar een blok met de nieuwe grootte. Het eerste deel van de gegevens blijft behouden, tot aan de kleinste van de oude en nieuwe grootte.
int *bigger = realloc(a, new_n * sizeof(*a));Het blok kan worden verplaatst
realloc kan het blok op zijn plaats vergroten, maar kan ook een nieuw blok reserveren, je gegevens kopiëren en het oude blok vrijgeven.
Hoe dan ook kan de oude pointer ongeldig worden. Vanaf dat moment moet je de geretourneerde pointer gebruiken.
a = realloc(a, new_n * sizeof(*a));
/* the old value of a may no longer be valid */De valkuil van zelftoewijzing
a = realloc(a, ...) schrijven lijkt netjes, maar is gevaarlijk: als realloc NULL retourneert, heb je a overschreven en de oorspronkelijke pointer verloren, waardoor het oude blok niet wordt vrijgegeven.
Gebruik in plaats daarvan een tijdelijke variabele.
int *tmp = realloc(a, new_n * sizeof(*a));
if (tmp == NULL) { /* a is still valid */ return 1; }
a = tmp;Een array veilig uitbreiden
Dit programma reserveert ruimte voor 3 gehele getallen en breidt die daarna met realloc uit naar 6, waarbij de eerste drie waarden behouden blijven.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *a = malloc(3 * sizeof(*a));
if (!a) return 1;
for (int i = 0; i < 3; i++) a[i] = i + 1;
int *tmp = realloc(a, 6 * sizeof(*a));
if (!tmp) { free(a); return 1; }
a = tmp;
for (int i = 3; i < 6; i++) a[i] = i + 1;
for (int i = 0; i < 6; i++) printf("%d\n", a[i]);
free(a);
return 0;
}Nieuwe bytes zijn niet geïnitialiseerd
Wanneer je een blok uitbreidt, bevat de extra ruimte aan het einde willekeurige inhoud, net als vers geheugen van malloc.
realloc behoudt je oude gegevens, maar zet het nieuwe gebied niet op nul. Initialiseer het voordat je het leest.
a = realloc(a, 6 * sizeof(*a));
for (int i = 3; i < 6; i++) a[i] = 0; /* clear new slots */De strategie van verdubbelen
Voor elk afzonderlijk element realloc aanroepen is traag. Een klassieke truc is de capaciteit te verdubbelen zodra de ruimte op is.
Zo blijft het aantal reallocaties klein terwijl de array groeit, wat gemiddeld goede prestaties oplevert.
if (count == cap) {
cap = cap ? cap * 2 : 4;
int *tmp = realloc(a, cap * sizeof(*a));
if (!tmp) { free(a); return 1; }
a = tmp;
}Een array opbouwen door toe te voegen
Dit programma begint leeg en voegt getallen toe, waarbij de capaciteit indien nodig wordt verdubbeld.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *a = NULL;
size_t count = 0, cap = 0;
for (int v = 1; v <= 5; v++) {
if (count == cap) {
cap = cap ? cap * 2 : 2;
int *tmp = realloc(a, cap * sizeof(*a));
if (!tmp) { free(a); return 1; }
a = tmp;
}
a[count++] = v;
}
for (size_t i = 0; i < count; i++) printf("%d\n", a[i]);
free(a);
return 0;
}realloc(NULL, n) werkt als malloc
Als je NULL als pointer doorgeeft, gedraagt realloc zich precies als malloc.
Daarom werkt beginnen met a = NULL in de lus voor verdubbeling: de eerste realloc reserveert het eerste blok.
int *a = NULL;
a = realloc(a, 4 * sizeof(*a)); /* same as malloc(4 * sizeof(*a)) */Een blok verkleinen
realloc kan een blok ook kleiner maken. De gegevens tot aan de nieuwe grootte blijven behouden; de rest wordt verwijderd.
Verkleinen kan geheugen teruggeven, al mogen implementaties het grotere blok behouden.
int *tmp = realloc(a, 2 * sizeof(*a)); /* down from more */
if (tmp) a = tmp;Overloop in de berekening voorkomen
Wanneer de capaciteit groot wordt, kan cap * sizeof(*a) een size_t laten overlopen en terugrollen naar een heel klein getal.
Bescherm de vermenigvuldiging bij enorme arrays, of gebruik reallocarray op systemen die deze functie aanbieden.
if (cap > SIZE_MAX / sizeof(*a)) { /* overflow */ return 1; }
int *tmp = realloc(a, cap * sizeof(*a));Korte controle
Test je begrip van realloc.
Samenvatting
realloc past de grootte van een heapblok aan en kan het verplaatsen, dus gebruik altijd de geretourneerde pointer.
Wijs de uitkomst eerst toe aan een tijdelijke variabele, zodat een fout het oorspronkelijke blok niet laat lekken. Verdubbel de capaciteit voor snelheid, initialiseer nieuwe posities en onthoud dat realloc(NULL, n) gelijkstaat aan malloc. Hierna verpak je deze logica in een herbruikbaar vectortype.
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 “Groeien met realloc” gratis?
Ja — de volledige tekst van “Groeien met realloc” 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 “Groeien met realloc”?
Pas de grootte van een dynamische array aan. 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 2 van 4.
Hoe lang duurt de les “Groeien met realloc”?
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
- Een array toewijzen
- Groeien met realloc
- Een herbruikbaar vectortype
- Vrijgeven en lekken voorkomen