Using an anonymous struct vs a named struct with typedef

They are pretty much equivalent. Actually, you can and should use the same name on both places. Use the same name unless you can come up with a good reason not to.

One situation where you want the non-anonymous is when you want pointers to an object of the same type, like in a linked list.

typedef struct Node {
    struct Node* next;
    int data;
} Node;

One alternative:

typedef struct Node Node;

struct Node {
    Node * next;
    int data;
};

According to Linus Torvalds, you should avoid typedefing structs unless you want to hide it. From the Linux kernel coding style guide:

Please don’t use things like vps_t. It’s a mistake to use typedef for structures and pointers. When you see a vps_t a; in the source, what does it mean? In contrast, if it says struct virtual_container *a; you can actually tell what a is.

Lots of people think that typedefs help readability. Not so. They are useful only for:

a) totally opaque objects (where the typedef is actively used to hide what the object is).

...

According to that, you should never use anonymous structs, and the typedefs are strictly for interfaces. So it should look like this:

typedef struct Node {
    struct Node* next;
    int data;
} Node;

But if you are really creating an interface, you should in general separate it into a header file and a source file. In this case, put the typedef in the header file and do NOT use the typedef:ed type at all in the source file.

struct Node {
    struct Node* next;
    int data;
} Node;

void insert(struct Node* head, int data) 
{
// Code
}

typedef struct Node Node;

void insert(Node* head, int data);

Taking all of the above into consideration, the only valid situation to use an anonymous struct is if you declare an object at the same time like this:

struct {
    int data;
    float more_data;
} myObject;

It doesn't really matter much. If you use the tagged form you can have pointers to struct Foo inside struct Foo (AKA Bar)

typedef struct Foo{
  int a;
  struct Foo *foop;
} Bar;

but there's no way to do that with the second form

typedef struct {
  int a;
  //Baz *p; not valid here since Baz isn't a typename yet
} Baz;

Some codebases prefer not to use typedefs at all and simply spell out struct Foo with the struct keyword every time.

Also, with the first form, you can refer to the type either via the tag (struct Foo) or with typedefs (Bar or any future/previous typedefs (you can do typedef struct Foo PreviousTypedef; before you provide the definition).

With the second form, on the other hand, you can only use the Baz typedef and possible future typedefs (you can't forward-typedef the struct since it doesn't have a tag).

(Note that typedef doesn't really define types in C. The struct optional_tag { /*...*/ } part does. Rather, typedef provides type aliases (so perhaps it should have been named typealias).)

Using an anonymous struct vs a named struct with typedef

Related

Recent Posts