How to initialize a structure with flexible array member

No, flexible arrays must always be allocated manually. But you may use calloc to initialize the flexible part and a compound literal to initialize the fixed part. I'd wrap that in an allocation inline function like this:

typedef struct person {  unsigned age;  char sex;  size_t size;  char name[];} person;inlineperson* alloc_person(int a, char s, size_t n) {  person * ret = calloc(sizeof(person) + n, 1);  if (ret) memcpy(ret,                  &(person const){ .age = a, .sex = s, .size = n},                  sizeof(person));  return ret;}

Observe that this leaves the check if the allocation succeeded to the caller.

If you don't need a size field as I included it here, a macro would even suffice. Only that it would be not possible to check the return of calloc before doing the memcpy. Under all systems that I programmed so far this will abort relatively nicely. Generally I think that return of malloc is of minor importance, but opinions vary largely on that subject.

This could perhaps (in that special case) give more opportunities to the optimizer to integrate the code in the surroundings:

#define ALLOC_PERSON(A,  S,  N)                                 \((person*)memcpy(calloc(sizeof(person) + (N), 1),               \                 &(person const){ .age = (A), .sex = (S) },     \                 sizeof(person)))

Edit: The case that this could be better than the function is when A and S are compile time constants. In that case the compound literal, since it is const qualified, could be allocated statically and its initialization could be done at compile time. In addition, if several allocations with the same values would appear in the code the compiler would be allowed to realize only one single copy of that compound literal.

There are some tricks you can use. It depends on your particular application.

If you want to initialise a single variable, you can define a structure of the correct size:

   struct  {        int age;        char sex;        char name[sizeof("THE_NAME")];    } your_variable = { 55, 'M', "THE_NAME" };

The problem is that you have to use pointer casting to interpret the variable as "person"(e.g. "*(person *)(&your_variable)". But you can use a containing union to avoid this:

union { struct { ..., char name[sizeof("THE_NAME")]; } x; person p;} your_var = { 55, 'M', "THE_NAME" };

so, your_var.p is of type "person".You may also use a macro to define your initializer, so you can write the string only once:

#define INIVAR(x_, age_, sex_ ,s_) \   union {\     struct { ..., char name[sizeof(s_)]; } x;\     person p;\    } x_ = { (age_), (sex_), (s_) }INIVAR(your_var, 55, 'M', "THE NAME");

Another problem is that this trick is not suitable to create an array of "person". The problem with arrays is that all elements must have the same size. In this case it's safer to use a const char * instead of a char[]. Or use the dynamic allocation ;)

A structure type with a flexible array member can be treated as if the flexible array member were omitted, so you can initialize the structure like this.

person p = { 10, 'x' };

However, there are no members of the flexible array allocated and any attempt to access a member of the flexible array or form a pointer to one beyond its end is invalid. The only way to create an instance of a structure with a flexible array member which actually has elements in this array is to dynamically allocate memory for it, for example with malloc.