flexible-array-member

By using flexible array members (FAMs) within structure types, are we exposing our programs to the possibility of undefined behavior? Is it possible for a program to use FAMs and still be a strictly conforming program? Is the offset of the flexible array member required to be at the end of the struct? The questions apply to both C99 (TC3) and C11 (TC1) . #include <stdio.h> #include <stdlib.h> #include <stddef.h> int main(void) { struct s { size_t len; char pad; int array[]; }; struct s *s = malloc(sizeof *s + sizeof *s->array); printf("sizeof *s: %zu\n", sizeof *s); printf("offsetof(struct s,

Is it valid C code to have flexible array members inside nested structs? So is my sample code below guarenteed to work as expected with a sane compiler? #include <stdio.h> #include <stdlib.h> struct d { char c; int ns[]; }; struct c { struct d d; }; struct b { struct c c; }; struct a { int n; struct b b; }; int main() { const int n = 10; struct a *pa = malloc(sizeof(*pa) + n * sizeof(pa->b.c.d.ns[0])); pa->n = n; pa->b.c.d.c = 1; for (int i = 0; i < n; ++i) { pa->b.c.d.ns[i] = i; } for (int i = 0; i < n; ++i) { printf("%d\n", pa->b.c.d.ns[i] + pa->b.c.d.c); } free(pa); } It's not valid per the

This question already has an answer here: Array of zero length 5 answers In reference to GCC's Zero Length Array explanation: This is particularly useful in the case when a struct is a header for a variable-length object. This is exactly my case. Furthermore, I am concerned with the alignment of my structs in the heap. In this case, I still really do not understand what's useful about zero length arrays. How are they related to this particular situation? EDIT: Is it that I can put as much "data" as I want in there? Basically it allows you to have a structure with a variable length array at the

A struct with a flexible array member, apparently, is not intended to be declared, but rather used in conjunction with a pointer to that struct. When declaring a flexible array member, there must be at least one other member, and the flexible array member must be the last member in that struct. Let's say I have one that looks like this: struct example{ int n; int flm[]; } Then to use it, I'll have to declare a pointer and use malloc to reserve memory for the structure's contents. struct example *ptr = malloc(sizeof(struct example) + 5*sizeof(int)); That is, if I want my flm[] array to hold

This is C99 code: typedef struct expr_t { int n_children; foo data; // Maybe whatever type with unknown alignment struct expr_t *children[]; } expr_t; Now, how do I allocate memory ? expr_t *e = malloc (sizeof (expr_t) + n * sizeof (expr_t *)); or expr_t *e = malloc (offsetof (expr_t, children) + n * sizeof (expr_t *)); ? Is sizeof even guaranteed to work on an type with flexible array member (GCC accepts it) ? CrazyCasta expr_t *e = malloc (sizeof (expr_t) + n * sizeof (expr_t *)); is well defined in C99. From the C99 specification 6.7.2.1.16: As a special case, the last element of a