There are two completely different ways to name a struct type. You can use: struct statement { /* ... */ }; in which case the name of the type is struct statement. Or you can use: typedef struct { /* ... */ } Statement; in which case the name of the type is Statement. Technically speaking, what the latter statement is doing is defining an anonymous (or tagless) struct type, then binding that type to a name. Some people think the former approach is better since: it keeps the identifier statement out of the regular identifier namespace (struct tags have their own namespace); you can forward-declare the type (you can't forward-declare a typedef since it's a definition, not a declaration); and it is clear when using the type that it is describing a structure and not a primitive type (which can be important sometimes since it affects how it works in function parameters and return values). Some people think the latter approach is better since: you don't have to type struct so often; and you can change whether something is struct or not without necessarily changing any of the code that uses the type. All of what I've described here applies to enum types, union types, or, for that matter, any other type. You could use: typedef int *IntPointer; to define an IntPointer type, for instance, if you would prefer to write that instead of int *. More on reddit.com

Programming languages allow you to use the principle of abstraction to define solutions to problems. Typedefs in C are nothing more than syntactic sugar which allows you to define a type synonym for a complex object. You use these type synonyms to make your code more readable and more understandable. It's the same reason you define functions. You want to replace a complex sequence of symbols with a simpler, more meaningful symbol. The true test for whether or not your code is easy to read and maintain is if an equally skilled individual can understand the code you've written. The same applies to you, the author, if you cannot understand the code you've written 6 to 12 months after you last touched it, that's proof that your code was not clearly written. More on reddit.com

IMHO, pointer typedefs are confusing. Using a typedef for integer types is important in many cases, as it means you can change the size everywhere at once, (e.g. add more flags than you thought you were going to use initially) and also it makes the code be self-documenting. More on reddit.com

However, I the syntax of typedef is typedef . The line of code in question doesn't seem to follow this question. It follows exactly the same syntax as a variable declaration, just with the keyword typedef out the front. So: char a[4]; means "declare a as an array of 4 characters", and: typedef char t[4]; means "define t as the type 'an array of 4 characters'". And yes, since it works just like a variable declaration, you can even define multiple types at once. For example: typedef char t4[4], t8[8], *tp, (*tpf)(void); would define: t4 to be the type 'an array of 4 characters`; t8 to be the type 'an array of 8 characters`; tp to be the type 'pointer to a character'; tpf to be the type 'pointer to a function that takes no arguments and returns a character'. So thinking of typedef as only permitting typedef is overly simplistic. (Fun fact: typedef has to be one of the "declaration specifiers" that go in front of the declarator list, but it need not be the first! Technically speaking, you could write it after the char type specifier instead — char typedef t[4]. But you'll confuse the heck out of anybody that looks at this line of code in the future... so please don't do that.) More on reddit.com