为什么允许命名嵌套结构？

Question

I stumbled upon a very strange feature of C: you can declare a named structure inside another structure provided that declare a member variable of that type at the same time:

struct Robot_st {
    int pos_x;
    int pos_y;
    struct BatteryStatus_st { /* <- named struct */
        int capacity;
        int load;
    } battery;
};

The inner structure becomes then available outside the structure as any other type, rendering strange code like this perfectly valid:

struct Robot_st my_robot = {2, 3, {200, 50}};
struct BatteryStatus_st battery_snapshot; /* <- use of inner struct */

memcpy(
    &battery_snapshot,
    &my_robot.battery,
    sizeof(struct BatteryStatus_st)
);

printf("robot position: %d,%d\n", my_robot.pos_x, my_robot.pos_y);
printf("battery load: %d%%\n", battery_snapshot.load);

Nesting unnamed structures feels right, because as you cannot access the type later, there is no confusion about the scope of the type. The above code is also not valid in C++, although the nested declaration is, because C++ understands it as a type in the namespace of the outer structure, so you need to access it using

struct Robot_st::BatteryStatus_st battery_snapshot;

which, despite feeling strange to declare both a type and a member at the same time, makes more sense.

So why is this construct valid in C? Is there any history/reason behind? Is there a use case for such a construct? (Mine was a mistake that led to failures, thus the question.)

Link to full working code .

Answer 1

In addition to the other two answers, here is a real usecase that calls for such a named inner struct:

struct LinkedList {
    //data members stored once per list
    struct LinkedListNode {
        //data members for each entry of the list
        struct LinkedListNode *next;
    } *head, *tail;
};

Its hard to write a more concise definition for the structure of a linked list.

An unnamed inner struct won't do: The code that inserts something into the linked list will likely have to declare local variables with node pointers. And there is no point in declaring the node structure outside of the linked list structure.

Answer 2

Such constructs were allowed in C originally because structure names occupied a universe all their own which never had any sort of scoping rules applied to it [struct member names did too, by the way, which is why some of the structure types in older standard libraries have prefixes on their members]. Because some code exists which uses structure names in a fashion inconsistent with scoping, the standard could not be changed to prohibit such usage without breaking existing code. While there are times when it's worthwhile to break existing code (eg to rid C of the abomination called gets ) this really isn't one of them.

Answer 3

Let's say I have this structure:

struct OuterStruct
{
    int a;
    struct InnerStruct
    {
        int i;
        int j;
    } b;
} s;

Now I can access sa , and I can even save it in a variable, to better handle it, pass it to functions, ...

int sa = s.a;

Well, now I want to do the same with sb , and to do so I need InnerStruct to have a name!

???? sb = s.b;   // here I have to use InnerStruct, otherwise sb would have no valid type!

The alternative would be to declare InnerStruct outside of OuterStruct , and then putting an instance of it inside as member of OuterStruct . But this would hide the fact that InnerStruct belongs to OuterStruct , making your intent less clear.

Answer 4

Well, this is legal in C:

struct BatteryStatus_st {
    int capacity;
    int load;
};

struct Robot_st {
    int pos_x;
    int pos_y;
    struct BatteryStatus_st battery;
};

and, as you pointed out, it is effectively identical to the code you posted (since C doesn't have the namespace/scoping rules introduced in C++).

If moving the "inner" type inside doesn't change anything, but may sometimes clarify intent, it would seem odd to prohibit it.