Why does C++11 not support anonymous structs, while C11 does?

Little effort has been made to maintain compatibility between C++ and C as the two languages evolve. Notice that variable length stack arrays have been in C since 1999, but weren't included in C++11. While they generally don't introduce things that contradict one another, the C++ committee isn't exactly bending over backwards to make sure that C++11 is compatible with versions of C beyond C89.

Furthermore, this feature would be quite complex in C++, because a struct is nothing more than a class. And an anonymous struct/class should have all of the features of a regular struct/class, yes? Otherwise, what's the point of having it?

What would it mean to construct a nameless struct? How would you define the constructor? Something as simple as:

struct Foo{    struct    {        size_t &x;    };};

is simply not possible because the inner struct has no constructor. And there's no way to specify one. A struct cannot construct the members of another struct within it.

For something like this:

struct Foo{    size_t outer;    struct    {        void SomeFunc();        size_t x;    };};

What this pointer does SomeFunc get? What would the type of this be, the nameless and unnamed type? How would you even define SomeFunc outside of the struct? The name of SomeFunc can't be Foo::SomeFunc, because SomeFunc lives in an inner scope.

It's just too complex for C++ to deal with. And certainly not worthwhile enough to bother with adding that complexity for.

To play devil's advocate - class and struct declarations are used often to wrap class-specific type declarations.

typedef struct {} name;

therefore should be allowable.

Therefore

struct {} 

should be as well.

However, if we consider this as just a declaration within a class' internal namespace, there would be no way to access the inside of the struct.

Because struct != namespace in C, C can make up rules like accessing an anonymous struct through the surrounding struct.

For C++ to allow this it would need to special case this situation, which would complicate name resolution.

Of course, playing devil's devil's advocate - C actually did this. It added an extra level to name resolution - if you can't find the name in a stuct check the struct's anonymous members. Which is a little magical, in a way that I can see C++ committee members finding annoying.

It also raises questions - if an anonymous struct can be accessed through its parent class, what about anonymous structs in a namespace.

Of course, if you really want to know, just ask Stroustrup - he responds to emails.