Question: I got the following code from internet:

```
struct {
   int x;
   struct {
       int y, z;
   } nested;
} i = { .nested.y = 5, 6, .x = 1, 2 };

```

The result is:

```
i.nested.y = 2
i.nested.z = 6

```

But I don't know why,the article from the net doesn't give any explanation.

Answer: 
Non-designated initializers operate always on the next element in the structure. So the latest `2` operates on what comes after `.x`, which is `.nested.y`. In the same way the `6` goes for the `nested.z`.

If an initializer has several values for an element, the last in the list wins.

But if you have compiler that implements designated initializers, there should be no reason not to use them. The example that you are giving is very much far fetched and not of much educational value.
No idea how I mis-read this first, thanks to Jens for pointing this out.

It's simply initializing successive elements "as always", but the designator is used to change the current element first to `.nested.y`, which is initialized to `5` and then the succeeding element `.nested.z` gets the `6`, and so on. The final `2` then overwrites `.nested.y`.

This is rather obfuscated code, since the number of initializers is larger than the number of `int` fields in the struct, something "fishy" (aka "clever") is going on.