Antwoord.

Geschiedenis van de kwestie

Variabele lengte arrays (VLA — Variable Length Arrays) zijn geïntroduceerd in de standaard C99, daarvoor moesten alle groottes van arrays bekend zijn op compileertijd. Ze stellen je in staat om arrays te declareren waarvan de grootte wordt bepaald door een variabele die alleen tijdens runtime bekend is.

Probleem

Onjuist gebruik van VLA leidt tot onopgeloste geheugenallocatiefouten (bijvoorbeeld, een te grote arraygrootte veroorzaakt een stack overflow), het is onmogelijk om VLA tussen verschillende compilers door te geven (niet allemaal ondersteunen ze het) en er is beperkte compatibiliteit met oudere standaarden van C en C++. Het debuggen wordt ook bemoeilijkt omdat het geheugen op de stack wordt toegewezen en niet in de heap, wat niet altijd verwacht wordt.

Oplossing

Bij het gebruik van VLA moet je je herinneren dat ze op de stack leven en niet globaal of statisch kunnen zijn. Het is beter om dynamische arrays te verkiezen via malloc, als flexibiliteit en gegarandeerde interactie met C++ nodig zijn. Voor compatibiliteit moet je beperkt blijven tot statische arrays of de C90-standaarden, als ondersteuning voor VLA niet gegarandeerd is.

Voorbeeldcode:

#include <stdio.h>

void process(size_t n) {
    int arr[n]; // VLA
    for(size_t i = 0; i < n; i++) arr[i] = i;
    for(size_t i = 0; i < n; i++) printf("%d ", arr[i]);
}

int main() {
    process(5);
    return 0;
}

Belangrijke kenmerken:

VLA worden op de stack toegewezen, hun grootte wordt bepaald door een variabele
VLA kunnen niet gebruikt worden voor globale/statische variabelen
Ondersteuning voor VLA is niet verplicht in sommige compilers en standaarden (bijvoorbeeld in C11 is het optioneel)

Vragen met een twist.

Kan je een statische array van variabele lengte declareren als static int arr[n]; binnen een functie?

Nee, statische variabelen moeten een bepaalde grootte hebben op compileertijd. Daarom zou static int arr[n]; met een variabele grootte een compileerfout veroorzaken.

Zal VLA automatisch worden vrijgegeven bij het verlaten van de functie?

Ja, VLA worden op de stack geplaatst en hun geheugen wordt automatisch vrijgegeven bij het verlaten van het blok/de functie, net als bij normale lokale variabelen.

Is het veilig om een VLA van zeer grote grootte toe te wijzen?

Nee, de stackgrootte is beperkt (bijvoorbeeld 1 MB of 8 MB). Pogingen om een grote VLA toe te wijzen zullen resulteren in een runtime-fout (stack overflow).

Typische fouten en anti-patterns

Gebruik van VLA met enorme groottes zonder foutcontroles
Doorgeven van VLA in functies als int arr[] zonder hun grootte op te geven
Verlangen dat VLA altijd door de compiler worden ondersteund

Voorbeeld uit het leven

Negatieve case

We schreven platformonafhankelijke code met VLA, de code compileerde niet op oudere of strikt ingestelde compilers.

Voordelen:

Gemak van syntaxis en leesbaarheid

Nadelen:

Verlies van draagbaarheid, problemen met onderhoud

Positieve case

We gebruikten VLA alleen voor lokale taken en daar waar een kleine grootte gegarandeerd was, voor grote arrays — malloc/free.