The typedef keyword in C enables developers to assign alternative names to existing data types, enhancing code readability and maintainability. It does not create new types but provides a convenient alias for an already defined type—be it fundamental, composite, or user-defined.

Basic Type Aliasing

Typedef is commonly used to define standardized integer types with clear semantics:

typedef signed char        int8_t;
typedef short              int16_t;
typedef int                int32_t;
typedef long long          int64_t;
typedef unsigned char      uint8_t;
typedef unsigned short     uint16_t;
typedef unsigned int       uint32_t;
typedef unsigned long long uint64_t;

These aliases allow platform-independent coding. When porting across systems, only the typedef definitions need adjustment, leaving the rest of the code unchanged.

Pointer and Array Type Definitions

typedef can simplify complex pointer and array declarations:

// Defines a pointer to int
typedef int *int_ptr;

// Defines an array of 10 pointers to int
typedef int *int_ptr_array[10];

// Defines a pointer to an array of 10 integers
typedef int (*array_of_ints)[10];

// Defines a flexible array type
typedef int flexible_array[];

// Defines a fixed-size 1D array
typedef int fixed_size_array[10];

// Defines a 2D array (10x10)
typedef int two_d_array[10][10];

With these, declaring variables becomes clearer:

int a[10] = {0};
int_ptr_array ptrs = {NULL};
for (int i = 0; i < 10; ++i) {
    ptrs[i] = &a[i];
}

for (int i = 0; i < 10; ++i) {
    printf("ptrs[%d] = %p\n", i, (void*)ptrs[i]);
}

Here, int_ptr_array represenst an array of ten int*, while array_of_ints denotes a pointer to a 10-element int array.

Struct and Enum Type Aliasing

typedef streamlines working with structures and enumerations:

typedef struct {
    int x, y;
    int width, height;
} rectangle_t;

// Pointer to rectangle_t
typedef rectangle_t *rect_ptr;

typedef enum {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
    FRIDAY, SATURDAY, SUNDAY
} week_day;

// Pointer to week_day
typedef week_day *day_ptr;

Now, rectangle_t r; declares a variable of the structure type, and rect_ptr p; creates a pointer to such a structure.

Function Type Definitions

Function types are not directly supported in C, but typedef helps manage function pointers:

// Function type returning int, taking two ints
typedef int func_type(int, int);

// Pointer to such a function
typedef int (*func_ptr)(int, int);

// Function returning a pointer to int
typedef int *return_ptr_func(int, int);

Usage example:

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

// Using func_ptr
func_ptr f = add;
printf("Result: %d\n", f(5, 7));

// Using func_type with indirection
func_type *f2 = add;
printf("Result: %d\n", (*f2)(5, 7));

Note: Function names can be assigned directly to function pointers without using &.

typedef vs #define

While both typedef and #define can create aliases, they differ significantly:

• Timing: #define is processed during preprocessing; typedef is handled at compile time.
• Scope: #define has no scope—it’s global unless undefined. typedef respects block scope.
• Multipel declarations: With typedef int* ptr_t;, you can write ptr_t a, b;—both a and b are pointers. With #define ptr_t int*, ptr_t a, b; makes a a pointer and b just an int.
• Flexibility: #define can expand any text; typedef is limited to type renaming.

Additionally, typedef behaves like a storage-class specifier in syntax, so invalid constructs like typedef static int arr[]; are rejected by the compiler.