Array declaration

In Funktionsparameterlisten sind zusätzliche Syntaxelemente innerhalb der Arraydeklaratoren erlaubt: das Schlüsselwort static und Qualifizierer , die in beliebiger Reihenfolge vor der Größenangabe erscheinen können (sie können auch auftreten, wenn die Größenangabe weggelassen wird).

In jedem Funktionsaufruf an eine Funktion, bei der ein Array-Parameter das Schlüsselwort static zwischen [ und ] verwendet, muss der Wert des aktuellen Parameters ein gültiger Zeiger auf das erste Element eines Arrays sein, das mindestens so viele Elemente enthält, wie durch expression angegeben:

void fadd(double a[static 10], const double b[static 10])
{
    for (int i = 0; i < 10; i++)
    {
        if (a[i] < 0.0) return;
        a[i] += b[i];
    }
}
// Ein Aufruf von fadd kann eine Überprüfung der Array-Grenzen zur Compile-Zeit durchführen
// und erlaubt auch Optimierungen wie das Vorabrufen von 10 Doubles
int main(void)
{
    double a[10] = {0}, b[20] = {0};
    fadd(a, b); // OK
    double x[5] = {0};
    fadd(x, b); // undefiniertes Verhalten: Array-Argument ist zu klein
}

Wenn qualifiers vorhanden sind, qualifizieren sie den Zeigertyp, in den der Array-Parametertyp transformiert wird:

int f(const int a[20])
{
    // in dieser Funktion hat a den Typ const int* (Zeiger auf const int)
}
int g(const int a[const 20])
{
    // in dieser Funktion hat a den Typ const int* const (konstanter Zeiger auf const int)
}

Dies wird häufig verwendet mit dem restrict Typqualifizierer:

void fadd(double a[static restrict 10],
          const double b[static restrict 10])
{
    for (int i = 0; i < 10; i++) // Schleife kann entrollt und neu geordnet werden
    {
        if (a[i] < 0.0)
            break;
        a[i] += b[i];
    }
}

Arrays variabler Länge

Wenn expression kein integer constant expression ist, ist der Deklarator für ein Array variabler Größe.

Jedes Mal, wenn der Kontrollfluss über die Deklaration läuft, expression wird ausgewertet (und muss immer zu einem Wert größer als Null ausgewerten), und das Array wird allokiert (entsprechend endet die lifetime einer VLA, wenn die Deklaration den Gültigkeitsbereich verlässt). Die Größe jeder VLA-Instanz ändert sich während ihrer Lebensdauer nicht, aber bei einem weiteren Durchlauf durch denselben Code kann sie mit einer anderen Größe allokiert werden.

#include <stdio.h>
int main(void)
{
   int n = 1;
label:;
   int a[n]; // 10-mal neu alloziert, jedes Mal mit einer anderen Größe
   printf("The array has %zu elements\n", sizeof a / sizeof *a);
   if (n++ < 10)
       goto label; // das Verlassen des Gültigkeitsbereichs einer VLA beendet ihre Lebensdauer
}

Wenn die Größe * ist, handelt es sich um eine Deklaration eines VLA mit nicht spezifizierter Größe. Eine solche Deklaration darf nur im Funktionsprototyp-Bereich erscheinen und deklariert ein Array eines vollständigen Typs. Tatsächlich werden alle VLA-Deklaratoren im Funktionsprototyp-Bereich so behandelt, als ob expression durch * ersetzt worden wäre.

void foo(size_t x, int a[*]);
void foo(size_t x, int a[x])
{
    printf("%zu\n", sizeof a); // gleich wie sizeof(int*)
}

Arrays mit variabler Länge und die davon abgeleiteten Typen (Zeiger auf sie, etc.) werden allgemein als "variably-modified types" (VM) bezeichnet. Objekte jedes variably-modified type dürfen nur im Blockbereich oder Funktionsprototypbereich deklariert werden.

extern int n;
int A[n];            // Fehler: VLA im Dateibereich
extern int (*p2)[n]; // Fehler: VM im Dateibereich
int B[100];          // OK: Array mit konstanter bekannter Größe im Dateibereich
void fvla(int m, int C[m][m]); // OK: VLA im Prototypenbereich

VLA muss automatische oder allokierte Speicherdauer haben. Zeiger auf VLA, aber nicht VLA selbst können ebenfalls statische Speicherdauer haben. Kein VM-Typ darf Verknüpfung haben.

void fvla(int m, int C[m][m]) // OK: Block-Bereich/Auto-Dauer-Zeiger auf VLA
{
    typedef int VLA[m][m]; // OK: Block-Bereich-VLA
    int D[m];              // OK: Block-Bereich/Auto-Dauer-VLA
//  static int E[m]; // Fehler: VLA mit statischer Dauer
//  extern int F[m]; // Fehler: VLA mit Verknüpfung
    int (*s)[m];     // OK: Block-Bereich/Auto-Dauer-VM
    s = malloc(m * sizeof(int)); // OK: s zeigt auf VLA im allokierten Speicher
//  extern int (*r)[m]; // Fehler: VM mit Verknüpfung
    static int (*q)[m] = &B; // OK: Block-Bereich/statische Dauer-VM}
}

Variabel modifizierte Typen können keine Mitglieder von Structs oder Unions sein.

struct tag
{
    int z[n]; // Fehler: VLA-Strukturmitglied
    int (*y)[n]; // Fehler: VM-Strukturmitglied
};

Falls der Compiler die Makrokonstante __STDC_NO_VLA__ auf den ganzzahligen Wert 1 definiert, dann werden VLA-Objekte mit automatischer Speicherdauer nicht unterstützt.

Die Unterstützung für VM-Typen und VLAs mit allokierter Speicherdauer ist zwingend vorgeschrieben.

Innerhalb einer struct -Definition kann ein Array unbekannter Größe als letztes Mitglied auftreten (sofern mindestens ein anderes benanntes Mitglied vorhanden ist), in welchem Fall es sich um einen Spezialfall handelt, der als flexible array member bekannt ist. Details siehe struct :

struct s { int n; double d[]; }; // s.d is a flexible array member
struct s *s1 = malloc(sizeof (struct s) + (sizeof (double) * 8)); // as if d was double d[8]

Ein Array-Typ und sein Elementtyp werden stets als identisch qualifiziert betrachtet, mit der Ausnahme, dass ein Array-Typ niemals als _Atomic -qualifiziert angesehen wird.

_Atomic darf nicht auf einen Array-Typ angewendet werden, obwohl ein Array von atomarem Typ erlaubt ist.

typedef int A[2];
// _Atomic A a0 = {0};    // Fehler
// _Atomic(A) a1 = {0};   // Fehler
_Atomic int a2[2] = {0};  // OK
_Atomic(int) a3[2] = {0}; // OK

• als Operand von _Alignof (since C11) (until C23) alignof (since C23)

Mehrdimensionale Arrays können in jeder Dimension variabel modifiziert werden wenn VLAs unterstützt werden (seit C11) :

int n = 10;
int a[n][2*n];