mjhjmtu

When should one of the following statements be used over the other?

typedef struct Foo
 int a;
 Bar;

and

typedef struct 
 int a;
 Bar;

and use it like

Bar bar1 = 5;

I understand the second on is an anonymous struct but not sure when should one be used over the other.

They are pretty much equivalent. Actually, you can use the same name on both places. And you should. 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;
;

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).)

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.

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

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;;

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.