> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C Flexible Array Member A flexible array member (FAM) is a C99 language feature that permits the final element of a `struct` to be declared as an incomplete array type (an array whose size is unknown). It provides a standardized compiler mechanism for defining variable-sized structures within a single, contiguous block of memory. ```c theme={"dark"} #include struct Vector { size_t length; /* Flexible array member */ int data[]; }; ``` ## Structural Constraints To satisfy the C standard, a flexible array member must adhere to strict structural rules: * **Position:** It must be the strictly final member of the `struct`. * **Prerequisites:** The `struct` must contain at least one named member prior to the FAM. A `struct` cannot consist solely of a flexible array. * **Composition:** A `struct` containing a FAM cannot be a member of another `struct`, nor can it be an element of an array. * **Initialization:** A FAM cannot be statically initialized using standard brace-enclosed initializer lists. ## Memory Layout and `sizeof` Behavior When the `sizeof` operator is applied to a `struct` containing a FAM, the result evaluates to the size of the structure *excluding* the flexible array. However, the compiler may append padding to the structure to satisfy the alignment requirements of the flexible array's data type. Therefore, `sizeof(struct Vector)` may be greater than the sum of the sizes of the preceding members, but it will never account for the elements of the array itself. Applying the `sizeof` operator directly to the flexible array member (e.g., `sizeof(vec->data)`) results in a compile-time error because the array is an incomplete type. ## Allocation Mechanics Because the compiler does not implicitly allocate memory for the incomplete array type, instances of the `struct` must be dynamically allocated. The total allocation size is calculated by adding the base size of the `struct` to the total byte size required for the desired array elements. ```c theme={"dark"} #include #include struct Vector { size_t length; int data[]; }; void allocate_vector(void) { size_t num_elements = 10; /* Calculate total contiguous memory required: base struct size + array size */ size_t total_size = sizeof(struct Vector) + (num_elements * sizeof(int)); /* Allocate the memory block */ struct Vector *vec = malloc(total_size); if (vec != NULL) { vec->length = num_elements; /* Memory is contiguous; vec->data[0] through vec->data[9] are now valid */ for (size_t i = 0; i < vec->length; i++) { vec->data[i] = 0; } free(vec); } } ``` ## Assignment and Copying Semantics When a structure containing a flexible array member is assigned by value (e.g., `*vec_copy = *vec_original;`), the compiler only copies the base members of the `struct`. The elements of the flexible array are silently ignored during the assignment. Similarly, using `sizeof(struct Vector)` in memory operations like `memcpy` will only copy the base structure and any padding, omitting the flexible array portion. To duplicate the entire structure including the array elements, memory operations must use the dynamically calculated total size. ```c theme={"dark"} #include #include struct Vector { size_t length; int data[]; }; void copy_vector(struct Vector *vec_copy, const struct Vector *vec_original) { /* * INCORRECT APPROACHES: * *vec_copy = *vec_original; * memcpy(vec_copy, vec_original, sizeof(struct Vector)); * * These operations copy only 'length' and padding, ignoring 'data' elements. */ /* CORRECT APPROACH: Copies the base struct and the flexible array elements */ size_t total_size = sizeof(struct Vector) + (vec_original->length * sizeof(int)); memcpy(vec_copy, vec_original, total_size); } ``` ## Pointer Arithmetic and Access Once allocated, the FAM behaves identically to a standard array. The compiler resolves accesses to `vec->data[i]` by computing the offset from the start of the `struct`, stepping over the preceding members and any compiler-inserted padding, directly into the dynamically allocated tail memory.
Tired of Poor C Skills? Fix That With Deep Grasping! Learn More