Array declaration

在函数参数列表中，数组声明符内允许使用额外的语法元素：关键字 static 和 限定符 ，它们可以在尺寸表达式之前以任意顺序出现（即使省略尺寸表达式时也可能出现）。

在每次对函数的 函数调用 中，若数组参数在 [ 和 ] 之间使用了关键字 static ，则实际参数的值必须是一个有效的指针，指向一个数组的首元素，且该数组至少包含 expression 所指定数量的元素：

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];
    }
}
// 对fadd的调用可执行编译时边界检查
// 同时允许诸如预取10个double等优化
int main(void)
{
    double a[10] = {0}, b[20] = {0};
    fadd(a, b); // 正确
    double x[5] = {0};
    fadd(x, b); // 未定义行为：数组参数过小
}

如果存在 qualifiers ，它们将限定数组参数类型转换后的指针类型：

int f(const int a[20])
{
    // 在此函数中，a 的类型为 const int*（指向 const int 的指针）
}
int g(const int a[const 20])
{
    // 在此函数中，a 的类型为 const int* const（指向 const int 的 const 指针）
}

这通常与 restrict 类型限定符一起使用：

void fadd(double a[static restrict 10],
          const double b[static restrict 10])
{
    for (int i = 0; i < 10; i++) // 循环可被展开和重排序
    {
        if (a[i] < 0.0)
            break;
        a[i] += b[i];
    }
}

变长数组

如果 expression 不是 整数常量表达式 ，则该声明符用于声明一个可变长度数组。

每当控制流经过该声明时， expression 会被求值（且必须始终得到一个大于零的值），同时数组会被分配（相应地，当声明离开作用域时，VLA的 lifetime 结束）。每个VLA实例的大小在其生命周期内不会改变，但在再次经过相同代码时，可能会分配不同大小的内存。

#include <stdio.h>
int main(void)
{
   int n = 1;
label:;
   int a[n]; // 重新分配10次，每次具有不同大小
   printf("The array has %zu elements\n", sizeof a / sizeof *a);
   if (n++ < 10)
       goto label; // 离开VLA的作用域将结束其生命周期
}

如果大小为 * ，则该声明用于一个未指定大小的可变长度数组。此类声明只能出现在函数原型作用域中，并声明一个完整类型的数组。实际上，函数原型作用域中的所有可变长度数组声明符都被视为 expression 被替换为 * 的情况。

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

可变长度数组及其派生类型（指向它们的指针等）通常被称为"可变修改类型"(VM)。任何可变修改类型的对象只能在块作用域或函数原型作用域中声明。

extern int n;
int A[n];            // 错误：文件作用域的VLA
extern int (*p2)[n]; // 错误：文件作用域的VM
int B[100];          // 正确：常量已知大小的文件作用域数组
void fvla(int m, int C[m][m]); // 正确：原型作用域的VLA

VLA必须具有自动或已分配的存储期。指向VLA的指针（而非VLA本身）也可以具有静态存储期。任何VM类型都不能具有链接。

void fvla(int m, int C[m][m]) // 正确：块作用域/自动存储期指针指向VLA
{
    typedef int VLA[m][m]; // 正确：块作用域VLA
    int D[m];              // 正确：块作用域/自动存储期VLA
//  static int E[m]; // 错误：静态存储期VLA
//  extern int F[m]; // 错误：具有链接的VLA
    int (*s)[m];     // 正确：块作用域/自动存储期VM
    s = malloc(m * sizeof(int)); // 正确：s指向已分配存储中的VLA
//  extern int (*r)[m]; // 错误：具有链接的VM
    static int (*q)[m] = &B; // 正确：块作用域/静态存储期VM}
}

可变修改类型不能作为结构体或联合体的成员。

struct tag
{
    int z[n]; // 错误：可变长度数组结构体成员
    int (*y)[n]; // 错误：可变长度结构体成员
};

若编译器将宏常量 __STDC_NO_VLA__ 定义为整型常量 1 ，则不支持具有自动存储期的VLA对象。

对具有分配存储期的VM类型和VLA的支持是强制要求的。

在 struct 定义内部，未知大小的数组可以作为最后一个成员出现（前提是至少存在一个其他命名成员），这种情况被称为 柔性数组成员 的特殊用法。详见 struct 说明：

struct s { int n; double d[]; }; // s.d 是柔性数组成员
struct s *s1 = malloc(sizeof (struct s) + (sizeof (double) * 8)); // 效果等同于 double d[8]

数组类型与其元素类型始终被视为具有相同限定，但数组类型永远不会被视为 _Atomic 限定。

_Atomic 不允许应用于数组类型，但允许原子类型的数组。

typedef int A[2];
// _Atomic A a0 = {0};    // 错误
// _Atomic(A) a1 = {0};   // 错误
_Atomic int a2[2] = {0};  // 正确
_Atomic(int) a3[2] = {0}; // 正确

• 作为 _Alignof (since C11) (until C23) alignof (since C23) 的操作数

多维数组在每个维度都可以被可变修改 （若支持VLA） （自C11起） ：

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