Réponse.

Historique de la question

Les tableaux à longueur variable (VLA — Variable Length Arrays) sont apparus dans la norme C99, avant cela, toutes les tailles de tableaux devaient être connues à l'étape de compilation. Ils permettent de déclarer des tableaux dont la taille est déterminée par une variable connue uniquement au moment de l'exécution.

Problème

Une mauvaise utilisation des VLA entraîne des erreurs de gestion de mémoire non traitées (par exemple, une taille de tableau trop grande entraînera un dépassement de pile), l'impossibilité de passer des VLA entre différents compilateurs (tout ne les supporte pas) et une compatibilité limitée avec les normes C et C++ plus anciennes. De plus, le débogage est compliqué par le fait que la mémoire est allouée sur la pile, et non dans le tas, ce qui n'est pas toujours attendu.

Solution

En utilisant des VLA, il faut se rappeler qu'ils vivent sur la pile et ne peuvent pas être globaux ou statiques. Il est préférable de privilégier les tableaux dynamiques via malloc, si de la flexibilité et une interaction garantie avec C++ sont nécessaires. Pour la compatibilité, il vaut mieux se limiter aux tableaux statiques ou aux normes C90, si le support des VLA n'est pas garanti.

Exemple de code :

#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;
}

Caractéristiques clés :

Les VLA sont alloués sur la pile, leur taille est déterminée par une variable
Les VLA ne peuvent pas être utilisés pour des variables globales/statistiques
Le support des VLA n'est pas obligatoire dans certains compilateurs et normes (par exemple, dans C11, c'est optionnel)

Questions pièges.

Peut-on déclarer un tableau statique à taille variable comme static int arr[n]; à l'intérieur d'une fonction ?

Non, les variables statiques doivent avoir une taille fixée lors de la compilation. Par conséquent, static int arr[n]; avec une taille variable entraînera une erreur de compilation.

Les VLA seront-ils automatiquement libérés à la sortie de la fonction ?

Oui, les VLA sont placés sur la pile et leur mémoire est automatiquement libérée à la sortie du bloc/fonction, tout comme pour les variables locales ordinaires.

Est-il sûr d'allouer un VLA très grand ?

Non, la taille de la pile est limitée (par exemple, 1 Mo ou 8 Mo). Tenter d'allouer un grand VLA entraînera une erreur d'exécution (dépassement de pile).

Erreurs typiques et anti-patterns

Utilisation de VLA avec des tailles énormes sans vérification des erreurs
Transmission des VLA dans des fonctions comme int arr[] sans indiquer leur taille
Attendre que les VLA sont toujours supportés par le compilateur

Exemple de la vie réelle

Cas négatif

Nous avons écrit un code multiplateforme avec des VLA, le code ne se compilait pas sur des compilateurs plus anciens ou strictement configurés.

Avantages :

Commodité de syntaxe et lisibilité

Inconvénients :

Perte de portabilité, problèmes de maintenance

Cas positif

Nous avons utilisé des VLA uniquement pour des tâches locales et là où une petite taille était garantie, pour de grands tableaux — malloc/free.