Risposta.

Storia della questione

Gli array a lunghezza variabile (VLA — Variable Length Arrays) sono stati introdotti nello standard C99; prima di ciò, tutte le dimensioni degli array dovevano essere conosciute al momento della compilazione. Consentono di dichiarare array la cui dimensione è determinata da una variabile, nota solo durante l'esecuzione.

Problema

Un uso errato dei VLA porta a errori di allocazione di memoria non gestiti (ad esempio, una dimensione dell'array troppo grande può causare uno stack overflow), impossibilità di passare VLA tra diversi compilatori (non tutti li supportano) e compatibilità limitata con standard più vecchi di C e C++. Inoltre, il debug è complicato dal fatto che la memoria viene allocata nello stack e non nel heap, il che non è sempre atteso.

Soluzione

Utilizzando i VLA, è necessario ricordare che vivono nello stack e non possono essere globali o statici. È meglio preferire array dinamici tramite malloc, se è necessaria flessibilità e interazione garantita con C++. Per la compatibilità, è consigliabile limitarsi a array statici o standard C90 se il supporto dei VLA non è garantito.

Esempio di codice:

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

Caratteristiche chiave:

I VLA vengono allocati nello stack, la loro dimensione è determinata da una variabile
I VLA non possono essere utilizzati per variabili globali/statiche
Il supporto dei VLA non è obbligatorio in alcuni compilatori e standard (ad esempio, in C11 è opzionale)

Domande trabocchetto.

È possibile dichiarare un array statico a lunghezza variabile come static int arr[n]; all'interno di una funzione?

No, le variabili statiche devono avere una dimensione fissa al momento della compilazione. Pertanto static int arr[n]; con dimensione variabile genererà un errore di compilazione.

I VLA verranno automaticamente liberati all'uscita dalla funzione?

Sì, i VLA vengono allocati nello stack e la loro memoria viene liberata automaticamente all'uscita dal blocco/funzione, proprio come le normali variabili locali.

È sicuro allocare VLA di dimensioni molto grandi?

No, la dimensione dello stack è limitata (ad esempio, 1 MB o 8 MB). Tentare di allocare un grande VLA porterà a un errore di esecuzione (stack overflow).

Errori comuni e anti-pattern

Utilizzo di VLA di dimensioni enormi senza controllo degli errori
Passaggio di VLA alle funzioni come int arr[] senza specificare la loro dimensione
Aspettarsi che i VLA siano sempre supportati dal compilatore

Esempio dalla vita reale

Caso negativo

Scrivere codice cross-platform con VLA, il codice non ha compilato su compilatori più vecchi o configurati rigorosamente.

Pro:

Convenienza della sintassi e leggibilità

Contro:

Perdita di portabilità, problemi di manutenzione

Caso positivo

Utilizzati VLA solo per compiti locali e dove è garantita una piccola dimensione, per array di grandi dimensioni — malloc/free.