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.

.c

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

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

.h

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; 

One time where the former is required is if you're making a linked list:

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

The typedef list is not visible inside of the struct definition, so you need to use the actual struct name to create a pointer to it.

If you don't have such a structure, you can use either one.

What you shouldn't do however is use a tag name that starts with an underscore, i.e.:

typedef struct _list {
    int data;
    struct list *next;
} list;

Because names starting with a underscore are reserved by the implementation.

The term anonymous struct is already used for something else: in nested structs (or unions) that don't have a name at all and whose fields are referred to as if they were entries in the parent.

The actual question about when to use one or the other is that you have to use the first form if you want to add a pointer to its own type inside it like so:

typedef struct Foo { struct Foo* Child; ... } Foo;

However, what I would prefer is to do that with a typedef like so:

typedef struct Foo Foo;
struct Foo {Foo* Child;};

A lot of other people are focusing on the self referential aspect of this, but another reason to avoid doing this is that due to the lack of namespaces in C. In some circles it is standard practice to not typedef structs to avoid struct qualifier and instead refer to structs with the full specifier (eg void foo(struct Foo* foo_ptr)). So if you wanted to maintain such a style, you wouldn't have the option to abuse anonymous structs, so this:

typedef struct {
  int a;
} Bar;

Bar bar1 = {5};

should always instead be

struct Bar{
  int a;
};

struct Bar bar1 = {5};

otherwise you couldn't even compile bar1's instantiation with out typedefing away the struct qualifier

When creating an opaque data type which is when the header only contains a forward declaration of the struct and the actual definition of it's members is in the source file. Since you cannot forward declare a typedef you'll have to give a struct a name. Example:

Foo.h

typedef struct Foo_ Foo;

Foo.c

struct Foo_ {
    int a;
};

Also when you have a recursive data structure such as linked list which everyone else has mentioned.

Prefer tagged structs, possibly type-aliased (==typedef'd) to the same tag (unless you have a good reason to use a different tag)

With those you can have:

1. links to the same type
2. forward struct declarations (opaque structs => fewer/leaner includes => faster compilations times)

1.

To have links to the same type you need a tag:

struct node { struct node *next; }; 

or like so:

typedef struct node_tp node_tp; struct node_tp { link_tp *next; }; 

2. To forward-declare, you also need a tag.

struct node_tp; /*can also typedef it at the same time: typedef struct node_tp node_tp*/

With these you can keep the struct opaque (never expose the layout in a public interfaces) or you can use them in a translation units that just pass around struct node_tp pointers without allocating or accessing the contents.

Opaque struct API are good for encapsulations. And even if the API doesn't make the struct actually opaque, using forward-declared structs can lead to greater translation unit decoupling => faster build times.

You can't do these two things with (typedefed or not) anonymous structs, so that's why I prefer tagging (and then I don't think about whether I need opaque types/same-type-link members).

You can typedef to avoid having to mention the struct keywords at use points. Linus Torvalds has expressed concerns against that (https://www.kernel.org/doc/html/v4.10/process/coding-style.html#typedefs) but you can just as well use a naming convention to encode the struct-ness into the tag, dispelling his readability concern.