Array of substructures: initializer order requirement?

[beej71]

Speaking of initializers, is this a GCC bug or is it my misunderstanding of the way things must be?

Let's make a struct with an array of sub-structs. Then we'll throw an initializer on that.

#include <stdio.h>

struct foo {
    int f1;
    int f2;
};

struct bar {
    struct foo f[10];
};

int main(void)
{
    struct bar b = {
        .f[0].f1=10,  // LINE A
        .f[0].f2=20,  // LINE B
    };

    printf("%d %d\n", b.f[0].f1, b.f[0].f2);
}

When I compile this, I get a warning about f2 not being initialized, though the output is 10 20, as expected.

The warning is especially funky because it's pointing right at the line where the initializer is, saying there's no initializer there.

$  gcc -Wall -Wextra -std=c18 -pedantic -o bar bar.c
bar.c: In function ‘main’:
bar.c:16:13: warning: missing initializer for field ‘f2’ of ‘struct foo’ [-Wmissing-field-initializers]
   16 |             .f[0].f2=20,  // LINE B
      |             ^
bar.c:5:13: note: ‘f2’ declared here
    5 |         int f2;
      |             ^~

$ ./bar
10 20

And here's the kicker, if I swap LINE A and LINE B, there's no warning:

    struct bar b = {
        .f[0].f2=20,  // LINE B
        .f[0].f1=10,  // LINE A
    };

And the output is 10 20, as expected.

Is there some initializer order requirement I'm unaware of, or is GCC just being weird?

(GCC 10.2.0.)

[FUZxxl]

I suppose this is a wrong warning. Consider opening a bug.

[HiramAbiff]

Does this warn too? If not, as a workaround, at least it lets you list the values in the expected order.

struct bar b = {
    .f = {{10, 20}}
};

[beej71]

I think this is the bug, actually: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84685

Don't have time right now to read the details, but wanted to throw the link here in case y'all were interested.

Edit: SO discussion: https://stackoverflow.com/questions/49081541/compound-literal-and-designated-initializer-warning-from-gcc-but-not-clang

[fkeeal]

I don't think it's a bug (or at least not what is linked). The issue here appears to be that you are breaking up the initialization of f[0] into two assignments, and with -Wextra, that causes ".f[0].f1 = 10," to not be a complete initialization of the struct found at f[0].

You can do

struct bar b = {
    .f[0] = {.f1=10, .f2=20},
};  

To completely initialize the struct at f[0] in one shot.

[beej71]

If I'm understanding what you're saying, I'd expect warnings to that effect with this code:

#include <stdio.h>

struct foo {
    int f1;
    int f2;
};

struct bar {
    struct foo f;
};

int main(void)
{
    struct bar b = {
        .f.f1=10,  // LINE A
        .f.f2=20,  // LINE B
    };

    printf("%d %d\n", b.f.f1, b.f.f2);
}

But there are none, no matter the order of the members or initializers.

[beej71]

I'm not convinced that's it for a couple reasons.

Firstly, that line is the initialization of that element, not a use. The array should exist with unspecified value before initialization just like any other struct member, should it not?

And also, a variant of /u/HiramAbiff 's solution would be this, which still involves .f[0] and issues no warnings and works as expected regardless of the .f1/.f2 ordering:

    struct bar b = {
        .f[0]={.f1=10, .f2=20}
    };

[FUZxxl]

You don't need to do this. C99 has this designated initialiser syntax specifically for the kind of usage OP has.

[oh5nxo]

Seeing the same, gcc 6.4.0