• 1Syntax
• 2Explanation
  • 2.1Arrays of constant known size
  • 2.2Variable-length arrays
  • 2.3Arrays of unknown size
  • 2.4Qualifiers
  • 2.5Assignment
  • 2.6Array to pointer conversion
  • 2.7Multidimensional arrays
• 3Notes
• 4References
• 5See also

In function parameter lists, additional syntax elements are allowed within the array declarators: the keywordstatic andqualifiers, which may appear in any order before the size expression (they may also appear even when the size expression is omitted).

In eachfunction call to a function where an array parameter uses the keywordstatic between[ and], the value of the actual parameter must be a valid pointer to the first element of an array with at least as many elements as specified byexpression:

void fadd(double a[static10],constdouble b[static10]){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 doublesint main(void){double a[10]={0}, b[20]={0};    fadd(a, b);// OKdouble x[5]={0};    fadd(x, b);// undefined behavior: array argument is too small}

Ifqualifiers are present, they qualify the pointer type to which the array parameter type is transformed:

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

This is commonly used with therestrict type qualifier:

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

Variable-length arrays

Ifexpression is not aninteger constant expression, the declarator is for an array of variable size.

Each time the flow of control passes over the declaration,expression is evaluated (and it must always evaluate to a value greater than zero), and the array is allocated (correspondingly,lifetime of a VLA ends when the declaration goes out of scope). The size of each VLA instance does not change during its lifetime, but on another pass over the same code, it may be allocated with a different size.

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

If the size is*, the declaration is for a VLA of unspecified size. Such declaration may only appear in a function prototype scope, and declares an array of a complete type. In fact, all VLA declarators in function prototype scope are treated as ifexpression were replaced by*.

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

Variable-length arrays and the types derived from them (pointers to them, etc) are commonly known as "variably-modified types" (VM). Objects of any variably-modified type may only be declared at block scope or function prototype scope.

externint n;int A[n];// Error: file scope VLAexternint(*p2)[n];// Error: file scope VMint B[100];// OK: file-scope array of constant known sizevoid fvla(int m,int C[m][m]);// OK: prototype-scope VLA

VLA must have automatic or allocated storage duration. Pointers to VLA, but not VLA themselves may also have static storage duration. No VM type may have linkage.

void fvla(int m,int C[m][m])// OK: block scope/auto duration pointer to VLA{typedefint VLA[m][m];// OK: block scope VLAint D[m];// OK: block scope/auto duration VLA//  static int E[m]; // Error: static duration VLA//  extern int F[m]; // Error: VLA with linkageint(*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 linkagestaticint(*q)[m]=&B;// OK: block scope/static duration VM}}

Variably-modified types cannot be members of structs or unions.

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

If the compiler defines the macro constant__STDC_NO_VLA__ to integer constant1, then VLA and VM types are not supported.

If the compiler defines the macro constant__STDC_NO_VLA__ to integer constant1, then VLA objects with automatic storage duration are not supported.

The support for VM types and VLAs with allocated storage durations is mandated.

Within astruct definition, an array of unknown size may appear as the last member (as long as there is at least one other named member), in which case it is a special case known asflexible array member. Seestruct for details:

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

If an array type is declared with aconst,volatile, orrestrict(since C99) qualifier (which is possible through the use oftypedef), the array type is not qualified, but its element type is:

An array type and its element type are always considered to be identically qualified, except that an array type is never considered to be_Atomic-qualified.

_Atomic is not allowed to be applied to an array type, although an array of atomic type is allowed.

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

• as the operand of_Alignof(since C11)(until C23)alignof(since C23)

Multidimensional arrays may be variably modified in every dimension if VLAs are supported(since C11):

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