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:

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:

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.

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.

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.

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.

/* 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.

Master C with Deep Grasping Methodology!

Learn More