Auszug aus http://www.schellong.de/c.htm

VLA: Variable-Länge-Array
VM: Variabel-Modifizierter Typ

VLAs sind Arrays, deren Elementeanzahl zur Laufzeit beliebig oft dynamisch festgelegt wird. Deshalb können VLAs nicht statisch sein (global; static), sondern nur bei/nach Funktions- und Blockeintritten ({) erzeugt werden; beim Funktionsverlassen werden sie zerstört. Auch können VLAs nicht in Strukturen enthalten sein (Man denke an die Konsequenzen!). VMs sind Adressen auf VLAs, VLA-Pointer.

VLAs sind ein wesentlich verbesserter Ersatz der alloca()-Funktion, die doch sehr oft problematisch ist und nur als compiler-interne Funktion recht sicher anwendbar ist.

In aller Regel werden VLAs im Stack-Speicher angelegt, was jeweils nur einige wenige Prozessortakte an Zeit beansprucht. Dies ist also eine ultraschnelle Allokation von Speicherplatz.

Deklaration bei Prototypen:

long Fu(int n, int m, long a[n][m]); long Fu(int n, int m, long a[*][*]); long Fu(int n, int m, long a[ ][*]); long Fu(int n, int m, long a[ ][m]);

Falls in Prototypen keine Objektnamen angegeben sind, muß man [*] bei VLAs verwenden.

Beispiele aus C9X-Draft:

extern int n; extern int m; void fcompat(void) { int a[n][6][m]; int (*p)[4][n+1]; int c[n][n][6][m]; int (*r)[n][n][n+1]; p = a; // Fehler - nicht kompatibel, da 4 != 6. r = c; // Kompatibel, aber definiertes Verhalten // nur falls n == 6 und m == n+1. } extern int n; int A[n]; // Error - file scope VLA extern int (*p2)[n]; // Error - file scope VM int B[100]; // OK - file scope but not VM void fvla(int m, int C[m][m]); // OK - VLA with prototype scope { typedef int VLA[m][m]; // OK - block scope typedef VLA struct tag { int (*y)[n]; // Error - y not ordinary identifier int z[n]; // Error - z not ordinary identifier }; int D[m]; // OK - auto VLA. static int E[m]; // Error - static block scope VLA extern int F[m]; // Error - F has linkage and is VLA int (*s)[m]; // OK - auto pointer to VLA. extern int (*r)[m]; // Error - r had linkage and is // a pointer to VLA. static int (*q)[m] = &B; // OK - q is a static block // pointer to VLA. } void copyt(int n) { typedef int B[n]; // B hat n ints, n jetzt bewertet. n += 1; // Nanu, vor Objektanlegen!? B a; // a hat n ints, n ohne += 1. int b[n]; // a and b sind unterschiedlich groß for (int i = 1; i < n; i++) a[i-1] = b[i]; } { int n = 4, m = 3; int a[n][m]; int (*p)[m] = a; // p == &a[0] p += 1; // p == &a[1] (*p)[2] = 99; // a[1][2] == 99 n = p - a; // n == 1 }

Konkretes Anwendungsbeispiel:

void Add(int n, int m, double a[n][n*m+300], double x); int main() { double b[4][308]; Add(4, 2, b, 2.17); return 0; } void Add(int n, int m, double a[n][n*m+300], double x) { for (int i=0; i < n; i++) for (int j=0, k=n*m+300; j < k; j++) a[i][j] += x; // a ist ein Zeiger auf ein VLA // mit n*m+300 Elementen }

Man beachte, daß in C Arrays niemals als Ganzes an Funktionen übergeben werden können, sondern stets nur Adressen darauf!

Deshalb hat oben a den Typ:

 double(*a)[n*m+300]

(Leider has Wiki keine Talk Seite)

Der Text gibt einen den Eindruck das "VLAs in Strukturen." nicht möglich sind. Das ist aber nicht korrekt - z.B. hat Ada VLAs in Strukturen. Die einzige "Konsequenz" ist das man hierfür VLS (Varable Lenght Structures) benötigt.

--MartinKrischik?

KategorieC KategorieCee KategorieSchellong