Antwort.

Hintergrund

Variable-Length-Arrays (VLA) wurden im C99-Standard eingeführt; zuvor mussten alle Arraygrößen zur Kompilierungszeit bekannt sein. Sie ermöglichen die Deklaration von Arrays, deren Größe zur Laufzeit anhand einer bekannten Variablen bestimmt wird.

Problem

Falsche Verwendung von VLA führt zu unbehandelten Speicherfehlern (z.B. kann eine zu große Array-Größe zu einem Stack Overflow führen), zur Unmöglichkeit, VLA zwischen verschiedenen Compilern zu übergeben (nicht alle unterstützen sie), und zu begrenzter Kompatibilität mit älteren C- und C++-Standards. Zudem wird die Fehlersuche erschwert, da der Speicher auf dem Stack und nicht im Heap zugewiesen wird, was nicht immer vorhersehbar ist.

Lösung

Bei der Verwendung von VLA sollte man sich bewusst sein, dass sie auf dem Stack leben und nicht global oder statisch sein können. Es ist besser, dynamische Arrays über malloc zu bevorzugen, wenn Flexibilität und garantierte Interaktion mit C++ erforderlich sind. Zur Sicherstellung der Kompatibilität sollte man sich auf statische Arrays oder die C90-Standards beschränken, wenn die Unterstützung von VLA nicht garantiert ist.

Codebeispiel:

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

Wichtige Merkmale:

VLA werden auf dem Stack zugewiesen, ihre Größe wird durch eine Variable bestimmt
VLA können nicht für globale/statische Variablen verwendet werden
Die Unterstützung von VLA ist in einigen Compilern und Standards (z.B. ist es in C11 optional) nicht obligatorisch

Fangfragen.

Kann man ein statisches Array variabler Länge wie static int arr[n]; innerhalb einer Funktion deklarieren?

Nein, statische Variablen müssen zur Kompilierungszeit eine definierte Größe haben. Daher wird static int arr[n]; mit variabler Größe einen Kompilierungsfehler verursachen.

Werden VLA automatisch freigegeben, wenn man aus der Funktion austritt?

Ja, VLA werden auf dem Stack platziert und ihr Speicher wird automatisch freigegeben, wenn man aus einem Block/einer Funktion austritt, ebenso wie bei normalen lokalen Variablen.

Ist es sicher, VLA mit sehr großer Größe zuzuweisen?

Nein, die Größe des Stacks ist begrenzt (z.B. 1 MB oder 8 MB). Der Versuch, ein großes VLA zuzuweisen, führt zu einem Laufzeitfehler (Stack Overflow).

Typische Fehler und Anti-Pattern

Verwendung von VLA mit enormen Größen ohne Fehlerüberprüfung
Übergabe von VLA an Funktionen als int arr[], ohne ihre Größe anzugeben
Erwarten, dass VLA immer vom Compiler unterstützt werden

Lebensbeispiel

Negativer Fall

Wir schrieben plattformübergreifenden Code mit VLA, der Code wurde auf älteren oder strengen Compilern nicht kompiliert.

Vorteile:

Bequemlichkeit der Syntax und Lesbarkeit

Nachteile:

Verlust der Portabilität, Probleme mit der Wartung

Positiver Fall

Wir verwendeten VLA nur für lokale Aufgaben und dort, wo eine kleine Größe garantiert ist, für große Arrays — malloc/free.