Объявление массива

В списках параметров функций в деклараторы массивов разрешено включать дополнительные синтаксические элементы: ключевое слово static и квалификаторы, которые могут располагаться в любом порядке перед выражением размера (их также можно указывать, если выражение размера опущено).

При каждом вызове функции, в котором параметр-массив функции использует ключевое слово static между [ и ], значение фактического параметра должно быть допустимым указателем на первый элемент массива, содержащего не меньше элементов, чем задано выражением выражение:

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];
    }
}
// a call to fadd may perform compile-time bounds checking
// and also permits optimizations such as prefetching 10 doubles
int main(void)
{
    double a[10] = {0}, b[20] = {0};
    fadd(a, b); // OK
    double x[5] = {0};
    fadd(x, b); // undefined behavior: array argument is too small
}

Если указаны квалификаторы, они применяются к типу указателя, в который преобразуется тип параметра-массива:

int f(const int a[20])
{
    // in this function, a has type const int* (pointer to const int)
}
int g(const int a[const 20])
{
    // in this function, a has type const int* const (const pointer to const int)
}

Часто это используется вместе с квалификатором типа restrict:

void fadd(double a[static restrict 10],
          const double b[static restrict 10])
{
    for (int i = 0; i < 10; i++) // loop can be unrolled and reordered
    {
        if (a[i] < 0.0)
            break;
        a[i] += b[i];
    }
}

Массивы переменной длины

Если выражение не является целочисленным константным выражением, декларатор объявляет массив переменного размера.

Каждый раз при прохождении потока управления через объявление вычисляется выражение (результат всегда должен быть больше нуля) и выделяется память для массива (соответственно, время существования VLA заканчивается, когда область видимости объявления завершается). Размер каждого экземпляра VLA не меняется в течение времени его существования, однако при следующем прохождении того же участка кода для него может быть выделен массив другого размера.

#include <stdio.h>

int main(void)
{
   int n = 1;
label:;
   int a[n]; // re-allocated 10 times, each with a different size
   printf("The array has %zu elements\n", sizeof a / sizeof *a);
   if (n++ < 10)
       goto label; // leaving the scope of a VLA ends its lifetime
}

Если размер равен *, объявляется VLA неопределённого размера. Такое объявление может встречаться только в области видимости прототипа функции и объявляет массив полного типа. Фактически все деклараторы VLA в области видимости прототипа функции обрабатываются так, как если бы выражение было заменено на *.

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

Массивы переменной длины и производные от них типы (указатели на них и т. д.) обычно называют «типами переменной модификации» (VM). Объекты любого типа переменной модификации можно объявлять только в блочной области видимости или области видимости прототипа функции.

extern int n;
int A[n];            // Error: file scope VLA
extern int (*p2)[n]; // Error: file scope VM
int B[100];          // OK: file-scope array of constant known size
void fvla(int m, int C[m][m]); // OK: prototype-scope VLA

VLA должны иметь автоматическую или выделенную длительность хранения. Указатели на VLA, но не сами VLA, также могут иметь статическую длительность хранения. Ни один тип VM не может иметь связывание.

void fvla(int m, int C[m][m]) // OK: block scope/auto duration pointer to VLA
{
    typedef int VLA[m][m]; // OK: block scope VLA
    int D[m];              // OK: block scope/auto duration VLA
//  static int E[m]; // Error: static duration VLA
//  extern int F[m]; // Error: VLA with linkage
    int (*s)[m];     // OK: block scope/auto duration VM
    s = malloc(m * sizeof(int)); // OK: s points to VLA in allocated storage
//  extern int (*r)[m]; // Error: VM with linkage
    static int (*q)[m] = &B; // OK: block scope/static duration VM}
}

Типы переменной модификации не могут быть членами структур или объединений.

struct tag
{
    int z[n]; // Error: VLA struct member
    int (*y)[n]; // Error: VM struct member
};

Если компилятор определяет макроконстанту __STDC_NO_VLA__ как целочисленную константу 1, то объекты VLA с автоматической длительностью хранения не поддерживаются.

Поддержка типов VM и VLA с выделенной длительностью хранения является обязательной.

В определении структуры массив неизвестного размера может быть последним членом (если имеется хотя бы ещё один именованный член); в таком случае он является особым случаем, известным как гибкий член массива. Подробности см. в статье о структурах:

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]

Тип массива и тип его элементов всегда считаются имеющими одинаковые квалификаторы, за исключением того, что тип массива никогда не считается квалифицированным _Atomic.

Квалификатор _Atomic нельзя применять к типу массива, но массив атомарного типа разрешён.

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

• операнда _Alignof(начиная с C11)(до C23)alignof(начиная с C23)

Многомерные массивы могут иметь переменную модификацию в каждом измерении, если поддерживаются VLA(начиная с C11):

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