在C中声明具有可变大小的全局结构变量

Question

I have a struct that looks like this.

struct MyStruct1 {
    int (*fn)();
    int b;
}

And another struct that looks like this.

struct MyStruct2 {
    int a;
    struct MyStruct1 b[0];
}

I would like to declare a global variable of type MyStruct2, somewhat like this.

int func1() { return 1; }
int func2() { return 2; }
struct MyStruct2 a = { 1, { func1, 5 }, { func2, 6 } };

However, I get a "Initializer Element is not a compile-time constant".

I would like to know (a) if it is even possible to globally declare a variable sized struct (or at least define a chunk of space, of the correct size, to have the values inserted into later), and (b) if it is, what am I doing wrong?

Answer 1

You cannot create arrays of size 0 in C legitimately. In C99 or C11, you can use a 'flexible array member' like this:

struct MyStruct2 {
    int a;
    struct MyStruct1 b[];
};

but structures that have a flexible array member can only usefully be created with dynamic memory allocation (other forms of allocation give you an unusable flexible array of size 0).

The older 'struct hack' version of a structure with a variable size array uses an array of size 1 in the structure. You can create global versions of such a structure with an array of size 1.

But basically, you are trying to do what the language prohibits you from doing, and not very surprisingly, you are failing.

What you do about this depends on what you need. Global variables are inherently somewhat undesirable, so there's an element of "you should be trying to avoid doing this". That said, the rules apply to file scope ( static ) variables too, and those have many uses.

You can use an explicit pointer in place of the array, and have separate allocations of the body of the struct MyStruct2 and its array of struct MyStruct1 members. You can forgo the global variable and use dynamically allocated structures with a flexible array member.

struct MyStruct2 *ms2 = malloc(sizeof(*ms2) + N * sizeof(ms2->b[0]));

This creates an struct MyStruct2 (as shown at the top of this answer) with N members in the array. Without any further changes, you can use ms2->b[0] through ms2->b[N-1] (well, apart from error checking that the malloc() succeeded).

Answer 2

It is not possible to declare a variable-size struct , neither locally nor globally. Every type has a fixed size determined at compile time.

The error message you report is surprising, however. If all the declarations you gave are at file scope, in the same file, in the order you gave them, then the initializer for variable a is a compile-time constant. However, it is not a proper initializer for a struct MyStruct2 ,

• because it specifies more elements than that struct type has members,
• because the initializer element for ab is an initializer for a struct MyStruct1 instead of for an array of such, and
• because even if you converted the last two initializer elements into one array initializer, it has more elements than there are elements in ab (ie more than zero).

If you want a dynamically-sized array, whether as a variable in its own right or as a member of a struct , then you must declare a pointer to it, and allocate memory for the elements dynamically. In that case, the elements are not themselves part of the struct ; only the pointer to them is. (That is different, by the way, from a fixed size array whose size is implicit in its initializer; these are possible only for independent types, though, not for types of struct or union members).

EDIT: C99 flexible arrays are a possible alternative, as ShafikYaghmour commented. These are similar, but not identical, to a struct element that is a pointer to a dynamically-allocated array. In that case, however, you not only cannot statically declare the array elements, you also cannot statically declare instances of the struct itself, so this wouldn't at all get around your initializer issue. There are several other quirks and limitations. Personally I see few advantages to flexible arrays, but they do make it a bit easier to properly free struct instances.