> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C Typedef Struct
A `typedef struct` in C is a syntactic construct that combines the `struct` keyword (which defines a composite data type) with the `typedef` keyword (which establishes a compiler-level type alias). This combination binds a structure definition to a new, single-word identifier, allowing developers to declare variables of that structure type without repeatedly invoking the mandatory `struct` tag required by standard C syntax.
## Standard Struct vs. Typedef Struct
In standard C, defining a structure creates a tag in the struct namespace. Declaring a variable requires both the `struct` keyword and the tag:
```c theme={"dark"}
struct Point {
int x;
int y;
};
struct Point p1; /* 'struct' keyword is mandatory */
```
Applying `typedef` abstracts the `struct` keyword away by mapping the entire structure definition to a new type name in the ordinary identifiers namespace:
```c theme={"dark"}
typedef struct {
int x;
int y;
} Point;
Point p1; /* 'struct' keyword is omitted */
```
## Syntactic Breakdown
The `typedef` keyword follows the grammar: `typedef [original_type] [alias_name];`.
When applied to a structure, the `[original_type]` is the entire block defining the structure's memory layout, and the `[alias_name]` is the identifier placed at the end of the declaration, immediately before the terminating semicolon.
```c theme={"dark"}
typedef struct { /* Start of [original_type] */
int member_a;
float member_b;
} /* End of [original_type] */
TypeAlias; /* [alias_name] */
```
## Tagged vs. Anonymous Typedef Structs
A `typedef struct` can be declared with or without a struct tag.
**1. Anonymous Typedef Struct**
The structure has no tag. It exists solely through the `typedef` alias.
```c theme={"dark"}
typedef struct {
int id;
} User;
```
**2. Tagged Typedef Struct**
The structure is given both a tag and an alias. The tag and the alias can be identical or different.
```c theme={"dark"}
typedef struct UserData { /* 'UserData' is the struct tag */
int id;
} User; /* 'User' is the typedef alias */
struct UserData u1; /* Valid */
User u2; /* Valid and equivalent */
```
## Self-Referential Structures
When a structure contains a pointer to its own type, an anonymous `typedef struct` cannot be used. The compiler parses the structure sequentially; therefore, the `typedef` alias does not exist until the closing brace is reached.
To declare a self-referential structure, a struct tag must be provided so the internal pointer can reference the incomplete type before the `typedef` evaluation concludes.
```c theme={"dark"}
/* INCORRECT: 'Node' is not yet defined inside the struct body */
typedef struct {
int data;
Node* next;
} Node;
/* CORRECT: The internal pointer uses the struct tag 'NodeTag' */
typedef struct NodeTag {
int data;
struct NodeTag* next;
} Node;
```
## Compilation and Memory Mechanics
* **No Memory Allocation:** A `typedef struct` declaration does not allocate memory. It strictly defines a memory layout and registers a type alias in the compiler's symbol table.
* **Namespace Separation:** C maintains separate namespaces for struct tags and ordinary identifiers (which includes `typedef` aliases). This is why a struct tag and a `typedef` alias can share the exact same name without causing a compiler collision.
* **Type Equivalence:** The compiler treats the `typedef` alias as strictly equivalent to the underlying `struct` type. It does not create a new distinct type for the purposes of type checking; it merely provides an alternative identifier for lexical analysis.
Tired of Poor C Skills? Fix That With Deep Grasping!
Learn More
