Page History

Flexible array members are a special type of array where the last element of a structure with more than one named member has an incomplete array type; that is, the size of the array is not specified explicitly within the structure.  A variety of different syntaxes have been used for declaring flexible array members.  For C99-compliant implementations, use the syntax guaranteed valid by C99 \[[ISO/IEC 9899:1999|AA. C References#ISO/IEC 9899-1999]\]. Section 6.7.2.1, paragraph 16: "Structure and Union Specifiers", says:

In particular, the size of the structure is as if the flexible array member were omitted except that it may have more trailing padding than the omission would imply.

Noncompliant Code Example (Declaration)

In this noncompliant code, an array of size 1 is declared, but when the structure itself is instantiated, the size computed for malloc() is modified to account for the actual size of the dynamic array. This is the syntax used by ISO C89.

...

The noncompliant example may be the only alternative for compilers that do not yet implement the C99 syntax.  Microsoft Visual Studio 2005 does not implement the C99 syntax.

Compliant Solution (Declaration)

This compliant solution uses the flexible array member to achieve a dynamically sized structure.

...

1. The incomplete array type must be the last element within the structure.
2. There cannot be an array of structures that contain flexible array members.
3. Structures that contain a flexible array member cannot be used as a member in the middle of another structure.
4. The sizeof operator cannot be applied to a flexible array.

Noncompliant Code Example (Reference)

In this noncompliant code, the flexible array structure is passed directly to a function which tries to print the array elements. This fails because passing the struct directly to the function actually makes a copy of the struct. When the struct is copied, the size of the flexible array member is not considered, consequently the array is truncated, and the function only has garbage in the array to print.

struct flexArrayStruct {
  int num;
  int data[1];
};

void print_array( struct flexArrayStruct structP) {
  size_t i;
  printf("Array is: ");
  for (i = 0; i < structP.num; i++) {
    printf("%d", structP.data[i]);
  }
  printf("\n");
}

size_t array_size;
size_t i;

/* initialize array_size */

/* space is allocated for the struct */
struct flexArrayStruct *structP
  = (struct flexArrayStruct *)
     malloc(sizeof(struct flexArrayStruct)
          + sizeof(int) * (array_size - 1));
if (structP == NULL) {
  /* Handle malloc failure */
}
structP->num = array_size;

for (i = 0; i < array_size; i++) {
  structP->data[i] = i;
}

print_array( *structP);

Compliant Solution (Reference)

Never allow a flexible array member to be copied. The above code can be fixed by changing the function to accept a pointer to the flexible array struct.

struct flexArrayStruct{
  int num;
  int data[];
};

void print_array( struct flexArrayStruct* structP) {
  size_t i;
  printf("Array is: ");
  for (i = 0; i < structP->num; i++) {
    printf("%d", structP->data[i]);
  }
  printf("\n");
}

/* ... */

size_t array_size = 10;
size_t i;

/* Initialize array_size */

/* Space is allocated for the struct */
struct flexArrayStruct *structP = (struct flexArrayStruct *)
  malloc(sizeof(struct flexArrayStruct) + sizeof(int) * array_size);
if (structP == NULL) {
  /* Handle malloc failure */
}

structP->num = array_size;

/* Access data[] as if it had been allocated
 * as data[array_size]
 */
for (i = 0; i < array_size; i++) {
  structP->data[i] = i;
}

print_array( structP);
return 0;

Risk Assessment

Failing to use the correct syntax can result in undefined behavior, although the incorrect syntax will work on most implementations.

...