The typedef keyword in C establishes alternative identifiers for existing types, enabling semantic abstraction and platform-independent code architectures. This mechanism allows developers to mask implementation details while exposing intent through domain-specific nomenclature.

Semantic Wrappers for Primitive Types

Aliasing fundamental types creates self-documenting interfaces and simplifies porting between architectures with differing word sizes:

#include <stdio.h>

typedef unsigned int Count;
typedef signed char Offset;

int main(void) {
    Count iterations = 100;
    Offset displacement = -5;
    
    printf("Processing %u items with step %d\n", iterations, displacement);
    return 0;
}

Anonymous Composite Types

Combining typedef with structure definitions eliminates syntactic overhead when declarign instances:

#include <stdio.h>

typedef struct {
    double latitude;
    double longitude;
} Coordinate;

int main(void) {
    Coordinate origin = {40.7128, -74.0060};
    printf("Location: %.4f, %.4f\n", origin.latitude, origin.longitude);
    return 0;
}

Indirection Abstractions

Pointer aliases clarify complex declarations, though they obscure multiple declaration behaviors:

#include <stdio.h>

typedef const char *Literal;

typedef int *IntHandle;

int main(void) {
    Literal msg = "Immutable text";
    int value = 42;
    IntHandle accessor = &value;
    
    printf("Message: %s, Value: %d\n", msg, *accessor);
    return 0;
}

Callback Type Specifications

Function pointer aliases transform verbose syntax in to readable type signatures, essential for polymorphic behavior:

#include <stdio.h>

typedef int (*BinaryOp)(int, int);

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

int power(int base, int exp) {
    int result = 1;
    for (int i = 0; i < exp; i++) {
        result *= base;
    }
    return result;
}

int execute(int x, int y, BinaryOp operation) {
    return operation(x, y);
}

int main(void) {
    int product = execute(6, 7, multiply);
    int squared = execute(2, 8, power);
    
    printf("Product: %d, Power: %d\n", product, squared);
    return 0;
}

Variant Type Implementations

Unions paired with typedef facilitate memory-efficient polymorphic storage:

#include <stdio.h>

typedef union {
    unsigned int bit_pattern;
    float real_value;
} RawFloat;

int main(void) {
    RawFloat converter;
    converter.real_value = 3.14159f;
    
    printf("Floating point: %.5f\n", converter.real_value);
    printf("Raw hex: 0x%08X\n", converter.bit_pattern);
    
    return 0;
}