C typedef

typedef in C creates an alias for an existing type. It does not create a new runtime object, add safety checks, or change memory layout; it simply gives a type another name that can make code easier to read. It is especially common with struct, enum, pointer, and function pointer types.

Overview: How typedef Works

A typedef declaration looks like a normal variable declaration, but the name being declared becomes a type name instead of a variable name. For example, typedef unsigned long long StudentId; means StudentId can be used anywhere the original type unsigned long long could be used.

The important point is that a typedef name is only an alias. If two typedef names refer to the same underlying type, C still treats them as compatible types. A StudentId and an unsigned long long have the same representation, the same size, and the same calling convention. The compiler does not automatically stop you from mixing aliases that represent different concepts but share the same underlying type.

typedef is most useful when the original type spelling is noisy or when a domain-specific name communicates intent. Structure aliases are common because they let you write Point p; instead of struct Point p;. Function pointer aliases are also common because raw function pointer declarations can be hard to read.

However, aliases can also hide useful information. A typedef for char * may make pointer ownership less obvious. A typedef for every primitive type can make a program harder to understand because readers must constantly look up what each alias means. Use typedef to clarify code, not to disguise ordinary C.

Syntax

typedef unsigned int Count;

typedef struct TagName {
    int member;
} AliasName;

Part	Meaning
`typedef`	The keyword that turns the declared name into a type alias.
`unsigned int`	The type that already exists. It could also be `struct Point`, an enum type, or a pointer type.
`Count` or `AliasName`	The new type name you will use in later declarations.
`struct TagName`	An optional structure tag. Keeping the tag is useful for self-referential structures and debugging.
Semicolon	Required at the end of every typedef declaration.

Read a typedef declaration the same way you read a variable declaration: identify the name being declared, then read the surrounding type. In typedef int *IntPtr;, IntPtr is an alias for int *. In typedef int (*Operation)(int, int);, Operation is an alias for a pointer to a function that takes two int arguments and returns int.

Examples

A Simple Alias for a Numeric Type

#include <stdio.h>

typedef unsigned long long StudentId;

int main(void) {
    StudentId id = 20260042ULL;
    unsigned long long raw = id;

    printf("Student id: %llu
", id);
    printf("Same size: %s
", sizeof id == sizeof raw ? "yes" : "no");

    return 0;
}

Output:

Student id: 20260042
Same size: yes

StudentId makes the purpose of the number clearer than writing unsigned long long everywhere. The second line shows that the alias has the same size as the original type. The alias improves readability, but it does not create a separate numeric type.

typedef with Structures

#include <stdio.h>

typedef struct Point {
    int x;
    int y;
} Point;

Point move(Point point, int dx, int dy) {
    point.x += dx;
    point.y += dy;
    return point;
}

int main(void) {
    Point start = {3, 4};
    Point end = move(start, 5, -2);

    printf("start: (%d, %d)
", start.x, start.y);
    printf("end: (%d, %d)
", end.x, end.y);

    return 0;
}

Output:

start: (3, 4)
end: (8, 2)

This common pattern defines both a structure tag, struct Point, and a typedef alias, Point. Code can use the shorter alias in variables, parameters, and return types. The function still receives and returns structure values, so move works on a copy of start.

typedef for Function Pointers

#include <stdio.h>

typedef int (*Operation)(int, int);

int add(int a, int b) {
    return a + b;
}

int multiply(int a, int b) {
    return a * b;
}

int apply(Operation operation, int left, int right) {
    return operation(left, right);
}

int main(void) {
    printf("add: %d
", apply(add, 6, 4));
    printf("multiply: %d
", apply(multiply, 6, 4));

    return 0;
}

Output:

add: 10
multiply: 24

Without the typedef, the parameter type for apply would be int (*operation)(int, int). That is valid C, but the alias Operation makes the function’s purpose easier to scan. The program passes function names to apply, and each function matches the aliased function pointer type.

Forward Declarations for Linked Structures

#include <stdio.h>

typedef struct Node Node;

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

int main(void) {
    Node third = {30, NULL};
    Node second = {20, &third};
    Node first = {10, &second};

    for (Node *current = &first; current != NULL; current = current->next) {
        printf("%d
", current->value);
    }

    return 0;
}

Output:

10
20
30

A structure cannot contain a complete member of its own type, but it can contain a pointer to its own type. The line typedef struct Node Node; introduces the alias before the full structure body, so the member Node *next; is legal inside the definition.

How It Works Step by Step

When the compiler reads a typedef declaration, it adds the alias name to the ordinary identifier namespace as a typedef name. Later, when that name appears in a type position, the compiler substitutes the aliased type during type checking. No runtime storage is created by the typedef itself.

If the alias names a structure type, the structure layout is still controlled by the structure definition. Members, alignment, padding, assignment behavior, and pointer behavior are exactly the same whether you write struct Point or Point. The alias only changes the spelling used in source code.

For pointer aliases, the pointer is part of the aliased type. This is why typedef int *IntPtr; can be surprising: IntPtr a, b; declares both a and b as pointers. The equivalent non-typedef declaration int *a, b; declares only a as a pointer and b as an int. This difference comes from how the alias is substituted as a complete type.

For function pointer aliases, typedef often removes visual complexity. The alias records the complete function pointer type once, then functions can accept callbacks or store callback arrays using a simple type name. The generated machine code is the same as it would be without the alias.

Common Mistakes

Thinking typedef Creates a New Type

typedef int UserId; and typedef int ProductId; do not create two incompatible types. Both are aliases for int. The names help humans understand intent, but C will still allow ordinary integer operations unless you add your own validation and careful API design.

Hiding Pointers Too Aggressively

A pointer alias can make declarations shorter, but it can also hide whether a function may modify memory through a pointer. For example, typedef char *String; may make String name; look like a high-level string object even though it is just a pointer. Prefer visible pointer syntax when ownership, mutability, or allocation matters.

Forgetting the Name Being Declared

In a typedef, the alias name appears where a variable name would normally appear. A function pointer alias must include parentheses around the alias name: typedef int (*Operation)(int, int);. Without the parentheses, the declaration describes a function returning a pointer, not a pointer to a function.

Removing Useful Structure Tags

Anonymous structure typedefs are legal, such as typedef struct { int x; int y; } Point;. But named tags are helpful for self-referential types, debugger output, and forward declarations. For public structures and linked data structures, prefer typedef struct Point { ... } Point; or a separate forward declaration.

Best Practices

Use typedef when the alias clearly communicates a domain concept or simplifies a genuinely complex type.
Keep structure tags when the type may need forward declarations or self-references.
Use function pointer typedefs for callback-heavy code because they make APIs easier to read.
Avoid aliasing ordinary primitive types unless the name adds real meaning, such as StudentId or ByteCount.
Be cautious with pointer typedefs. Do not hide ownership or mutability behind a friendly-looking name.
Name typedef aliases consistently. Many C projects use PascalCase for typedef names and uppercase names for constants.
Remember that typedefs are compile-time aliases. They do not allocate memory, initialize values, or enforce business rules.

Practice Exercises

Create a typedef named Celsius for double. Write a function that converts a Celsius value to Fahrenheit and prints the result.
Define a tagged structure struct Rectangle with a typedef alias Rectangle. Store width and height, then write an area function.
Create a function pointer typedef named Comparer for a function that compares two integers. Write one comparison function and call it through the alias.

Summary

typedef creates another name for an existing type.
A typedef does not change memory layout, runtime behavior, or type compatibility.
Structure typedefs reduce repeated struct spelling and are common in C APIs.
Function pointer typedefs make callback declarations much easier to read.
Pointer typedefs should be used carefully because they can hide important pointer behavior.
The best typedef names clarify intent without making ordinary C harder to see.

C typedef

Overview: How typedef Works

Syntax

Examples

A Simple Alias for a Numeric Type

typedef with Structures

typedef for Function Pointers

Forward Declarations for Linked Structures

How It Works Step by Step

Common Mistakes

Thinking typedef Creates a New Type

Hiding Pointers Too Aggressively

Forgetting the Name Being Declared

Removing Useful Structure Tags

Best Practices

Practice Exercises

Summary

Table of Contents