C: Initialize custom array size in struct at compile time

I suggest that you define a type for each size of Object that you want.

You could simplify it by defining some macros:

#include <stdint.h>
#include <stdlib.h>

#define OBJINIT(x) (Object##x){.size = x }
#define DEFOBJ(x)     \
typedef struct        \
{                     \
  uint8_t size;       \
  uint8_t array[x];   \
} Object##x;          \
Object##x *CreateObject##x() {          \
    Object##x *rv = malloc(sizeof *rv); \
    if(!rv) exit(1);                    \
    *rv = OBJINIT(x);                   \
    return rv;                          \
}

// Define the types with the sizes you need:
DEFOBJ(2)
DEFOBJ(5)

int main(void) {
    Object2 o2 = OBJINIT(2);         // an initialized automatic variable
    
    Object5* o5p = CreateObject5();  // an initialized dynamically allocated variable
    free(o5p);
}

The normal way to allocate the size of an array like this so you can easily change it and use the size of it elsewhere in the code is to use a macro.

#define MYARRAYSIZE 10

typedef struct 
{
  uint8_t size;
  uint8_t array[MYARRAYSIZE];
}Object_t;

The other way to do is to make it a pointer and then allocate the memory dynamically at runtime with malloc. Much bigger arrays can be declared this way.

#define MYARRAYSIZE 10

typedef struct 
{
  uint8_t size;
  uint8_t *array;
}Object_t;
 ...
Object_t Object;
Object.array = (uint8_t *)malloc(MYARRAYSIZE*sizeof(uint8_t));

If one uses dialects that extend the semantics of the language by relaxing the "strict aliasing rule" sufficiently to uphold the Spirit of C principle "Don't prevent the programmer from doing what needs to be done", a common approach is to do something like:

struct polygon { int sides; int coords[]; };

struct poly5 { int sides; int coords[10]; }
  const myPentagonn = {5, {0,-5, 4,-3, 3,5, -3,5, -4,-3} };

#define myPentagon (*((struct polygon*)&myPentagonn))

In pre-standard dialects, it would often have been necessary to either declare polygon as containing a zero-element array, or if compilers decided to be annoying, a single-element array, but there was never any doubt about whether functions should be able to act upon multiple similar structure types interchangeably as exemplified here. Such constructs, with a few adjustments, were recognized in the 1974 dialect of C, and dialects suitable for low-level programming will support them without regard for whether or not the Standard would mandate such support.

Some clang/gcc fans who don't accept the intentions of the authors of the Standard as expressed in the published Rationale documents will insist that any code which would require the use of -fno-strict-aliasing is broken. The intention of the Standard, however, was to treat support for such constructs as a quality-of-implementation issue outside the Standard's jurisdiction. An implementation which is intended for tasks that would never need nor benefit from any kind of low-level memory manipulation might be more efficient for such tasks than would be one that accommodates such needs, but that doesn't mean code that is intended to work with memory at a low level should jump through hoops to be compatible with such specialized implementations or configurations.

#include <stdio.h>
#include <stdint.h>

typedef struct Object
{
  uint8_t size;
  uint8_t array[5];
} Object;

int main() {
    Object o = { .size = 2,  {1, 2}};
    printf("%d %d\n", o.array[0], o.array[1]);
}

This compiles for me with cc -std=c99 in clang 14.0.0 on macOS. It outputs:

1 2

First of all, whenever you find yourself with exotic requirements like this, please take a step back and see if you can't simplify the program instead. Using obscure macro hacks is always the last resort - and even then mostly just when maintaining old code.

That being said, the least obscure solution might be to create an unique typedef per object, based on variable name. And then declare a variable of that type in the same macro. Then it would be possible to use it anywhere.

One possible solution:

#define create_obj(name, ...)                        \
typedef struct                                       \
{                                                    \
  uint8_t size;                                      \
  uint8_t array[sizeof( (uint8_t[]){__VA_ARGS__} )]; \
} obj_##name;                                        \
                                                     \
obj_##name name =                                    \
{                                                    \
  .size = sizeof( (uint8_t[]){__VA_ARGS__} ),        \
  .array = { __VA_ARGS__ }                           \
}

A type with the variable name appended will be created. It will not use a flexible array member but a fixed size array. It will not need dynamic allocation, it will not need to rely on exotic corner-case rules or non-standard extensions.

If another member type than uint8_t would be used, then simply determine the array size with the usual trick:

sizeof((type[]){ __VA_ARGS__ }) / sizeof(type[0])

Example:

#include <stdint.h>
#include <stdio.h>
#include <inttypes.h>

#define create_obj(name, ...)                        \
typedef struct                                       \
{                                                    \
  uint8_t size;                                      \
  uint8_t array[sizeof( (uint8_t[]){__VA_ARGS__} )]; \
} obj_##name;                                        \
                                                     \
obj_##name name =                                    \
{                                                    \
  .size = sizeof( (uint8_t[]){__VA_ARGS__} ),        \
  .array = { __VA_ARGS__ }                           \
}


create_obj(filescope_obj,1,2,3);

int main (void) 
{
  create_obj(local_obj,1,2,3,4,5);

  for(size_t i=0; i<filescope_obj.size; i++)
  {
    printf("%"PRIu8 " ", filescope_obj.array[i]);
  }
  puts("");
  for(size_t i=0; i<local_obj.size; i++)
  {
    printf("%"PRIu8 " ", local_obj.array[i]);
  }
}

Output:

1 2 3 
1 2 3 4 5 

It would be great if Compound Literals could be used for this:

Object o = { .size = 16, .array = (uint8_t[16]) { 0 } };
// Error: initializer element is not computable at load time

However such an array literal is - as usual with arrays - coerced to a pointer to its first element. So the type is actually uint8_t*, which cannot be used to initialise the .array. That trick only works for top-level arrays in GCC, like

uint8_t array[] = (uint8_t[16]) { 0 };

but that's not what we want, we want to put the array in an Object. You could write a normal array initialiser with as many bytes as you need:

Object o = { .size = 16, .array = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } };

But that's too cumbersome and nobody wants to count them. Large arrays would need macro magic to do the repetition, no good.

There is however another GCC extension that helps with this: Designated Initialisers. Just like the .array designator for the Object struct, you can use index or even range designators to initialise array members, and thereby create an array of the desired size:

Object o = { .size = 16, .array = { [0 ... 15] = 0 } };

Notice this only works for global (or static) declarations though.