基本概念

typedef 是C语言的关键字，用于为已有数据类型创建别名。它不创建新类型，只是提供新名称。

// 基本语法
typedef existing_type new_type_name;

核心特性

• 编译时处理：不同于预处理的文本替换
• 类型检查：编译器进行完整的类型检查
• 作用域规则：遵循C语言的标准作用域规则

主要用途

1. 为基本类型创建别名

typedef unsigned int UINT32;
typedef float REAL;
typedef char BYTE;

UINT32 age = 25;      // 实际是 unsigned int
REAL salary = 5000.5; // 实际是 float
BYTE data = 0xFF;     // 实际是 char

2. 为数组类型创建别名

// 一维数组
typedef int INT_ARRAY[10];
INT_ARRAY numbers;  // int numbers[10]

// 二维数组
typedef int MATRIX[3][3];
MATRIX m1, m2;      // 两个3x3矩阵

// 字符数组（原始问题示例）
typedef char ARRAY20[20];
ARRAY20 name;       // char name[20]

3. 为结构体创建别名（最常用）

// 方式1：分开定义
struct Point {
    int x, y;
};
typedef struct Point Point;

// 方式2：合并定义（推荐）
typedef struct {
    char name[50];
    int age;
    float salary;
} Employee;

// 使用（无需struct关键字）
Point p1;
Employee emp1;

4. 为指针类型创建别名

// 基本指针
typedef int* PTR_INT;
PTR_INT p1, p2;  // 两个int指针

// 指向数组的指针
typedef int (*PTR_TO_ARRAY)[10];
int arr[10];
PTR_TO_ARRAY p = &arr;

// 多级指针
typedef int** PTR_PTR_INT;

5. 为函数指针创建别名

// 函数指针类型
typedef int (*MathFunc)(int, int);

// 实际函数
int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

// 使用
MathFunc operation;
operation = add;
printf("5+3=%d\n", operation(5, 3));  // 8

operation = multiply;
printf("5*3=%d\n", operation(5, 3));  // 15

---

typedef vs #define

特性	typedef	#define
处理阶段	编译时	预处理时
作用域	遵循C作用域规则	文件作用域
类型检查	有类型检查	文本替换，无类型检查
指针声明	更安全清晰	容易出错
数组/函数	正确处理	可能有问题
调试信息	保留类型名	不保留

关键区别示例

// typedef - 安全
typedef int* IntPtr;
IntPtr a, b;  // a和b都是int指针 ✓

// #define - 危险
#define INT_PTR int*
INT_PTR a, b;  // 展开为: int* a, b; 
               // 只有a是指针，b是int! ✗

---

实际应用场景

1. 提高代码可读性

// 难懂的原始代码
unsigned long int (*func_array[10])(unsigned long int*);

// 使用typedef清晰化
typedef unsigned long int (*Callback)(unsigned long int*);
Callback func_array[10];  // 清晰易懂

2. 简化复杂声明

// 恐怖的原始声明：signal函数
void (*signal(int sig, void (*func)(int)))(int);

// 用typedef分解
typedef void (*SignalHandler)(int);
SignalHandler signal(int sig, SignalHandler func);  // 清晰！

分解步骤：

1. 识别最内层：void (*func)(int) → 函数指针类型
2. 创建别名：typedef void (*SignalHandler)(int)
3. 替换：SignalHandler signal(int sig, SignalHandler func)

3. 平台无关编程

#ifdef _WIN32
    typedef unsigned __int64 UINT64;
    typedef __int64 INT64;
#else
    typedef unsigned long long UINT64;
    typedef long long INT64;
#endif

// 统一使用
UINT64 file_size = 1024ULL * 1024 * 1024 * 1024;

4. 数据结构抽象

// 链表
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 二叉树
typedef struct TreeNode {
    int value;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// 动态数组
typedef struct {
    int* data;
    size_t size;
    size_t capacity;
} DynamicArray;

5. 模块化设计（不透明指针模式）

// database.h - 头文件（公开接口）
typedef struct DatabaseConnection* DBHandle;

// 用户只能看到指针，不知道内部结构
DBHandle db_connect(const char* connection_string);
int db_query(DBHandle handle, const char* sql);
void db_close(DBHandle handle);

// database.c - 实现文件（内部细节）
struct DatabaseConnection {
    int socket_fd;
    char hostname[100];
    int port;
    void* internal_data;
    // 私有字段，用户不可见
};

// 实现函数
DBHandle db_connect(const char* connection_string) {
    struct DatabaseConnection* conn = malloc(sizeof(struct DatabaseConnection));
    // 初始化...
    return conn;  // 隐式转换为不透明指针
}

为什么能编译？

• 指针大小固定（32位4字节，64位8字节）
• 编译器只需要知道这是指针类型
• 实现了信息隐藏和封装

---

高级模式

1. 回调函数框架

// 定义事件类型和回调函数类型
typedef enum {
    EVENT_CLICK,
    EVENT_KEYPRESS,
    EVENT_TIMER
} EventType;

typedef void (*EventHandler)(EventType type, void* data);

// 事件管理器
typedef struct {
    EventHandler handlers[10];
    int count;
} EventManager;

void register_handler(EventManager* mgr, EventHandler handler) {
    mgr->handlers[mgr->count++] = handler;
}

2. 泛型编程模拟

// 比较函数类型
typedef int (*CompareFunc)(const void*, const void*);

// 泛型排序函数
void generic_sort(void* array, size_t count, size_t elem_size, CompareFunc cmp) {
    for (size_t i = 0; i < count - 1; i++) {
        for (size_t j = i + 1; j < count; j++) {
            void* elem1 = (char*)array + i * elem_size;
            void* elem2 = (char*)array + j * elem_size;
            if (cmp(elem1, elem2) > 0) {
                // 交换元素
                char temp[elem_size];
                memcpy(temp, elem1, elem_size);
                memcpy(elem1, elem2, elem_size);
                memcpy(elem2, temp, elem_size);
            }
        }
    }
}

3. 状态机模式

typedef enum {
    STATE_IDLE,
    STATE_RUNNING,
    STATE_PAUSED,
    STATE_STOPPED
} State;

typedef State (*StateHandler)(void* context);

typedef struct {
    State current_state;
    StateHandler handlers[4];
    void* context;
} StateMachine;

State process_state(StateMachine* sm) {
    return sm->handlers[sm->current_state](sm->context);
}

---

注意事项

1. 作用域正确使用

// 文件作用域（推荐）
typedef int CustomerID;

void process_order() {
    // 函数作用域（C99+）
    typedef float DiscountRate;
    DiscountRate rate = 0.15f;
}

// 块作用域（C99+）
if (condition) {
    typedef double PrecisionValue;
    PrecisionValue value = 3.14159265358979;
}

2. 与const的正确结合

typedef char* String;

const String s1;     // char* const s1（指针常量）
String const s2;     // 同上，指针不能改，内容能改
const char* s3;      // 指向常量的指针，指针能改，内容不能改

// 清晰的定义
typedef const char* ReadOnlyString;
typedef char* const ConstantPointer;

3. 避免的陷阱

// 陷阱1：过度抽象
typedef int Integer;  // 没必要，反而降低可读性
typedef float Float;

// 陷阱2：误导性名称
typedef int Handle;   // Handle是指针还是整型？不清晰
typedef void* Handle; // 更好

// 陷阱3：作用域混乱
void func1() {
    typedef int SpecialType;
    SpecialType x;  // OK
}

void func2() {
    // SpecialType x;  // 错误！不在作用域内
}

4. 好的实践

// 有意义的名字
typedef int UserID;
typedef float Price;
typedef char ProductCode[16];

// 平台抽象层
#ifdef USE_DOUBLE_PRECISION
    typedef double Real;
#else
    typedef float Real;
#endif

// 配置相关
typedef struct {
    int max_connections;
    int timeout_ms;
    char server_url[256];
} Config;

// 函数指针清晰化
typedef void (*LogCallback)(const char* message, int level);
typedef int (*DataProcessor)(const void* input, void* output, size_t size);

---

实际案例

案例1：配置管理系统

// config.h
typedef struct ConfigManager* ConfigHandle;

typedef enum {
    CONFIG_INT,
    CONFIG_FLOAT,
    CONFIG_STRING,
    CONFIG_BOOL
} ConfigType;

typedef union {
    int int_val;
    float float_val;
    char* str_val;
    int bool_val;
} ConfigValue;

ConfigHandle config_create(const char* filename);
int config_get(ConfigHandle handle, const char* key, ConfigType type, ConfigValue* out);
void config_destroy(ConfigHandle handle);

案例2：插件系统

// plugin.h
typedef struct Plugin* PluginHandle;

typedef struct {
    const char* name;
    int version;
    void (*init)(void* context);
    void (*process)(void* data);
    void (*cleanup)(void);
} PluginInterface;

typedef PluginHandle (*PluginLoader)(const char* path);
typedef void (*PluginUnloader)(PluginHandle);

// 使用
PluginHandle load_plugin(const char* path, PluginInterface* iface);

案例3：网络协议栈

// network.h
typedef struct Socket* SocketHandle;
typedef struct Packet* PacketHandle;

typedef enum {
    PROTOCOL_TCP,
    PROTOCOL_UDP,
    PROTOCOL_ICMP
} ProtocolType;

typedef void (*PacketHandler)(PacketHandle packet, void* user_data);

SocketHandle socket_create(ProtocolType proto);
int socket_bind(SocketHandle sock, const char* ip, int port);
int socket_listen(SocketHandle sock, PacketHandler handler, void* user_data);

---

总结

typedef的核心价值

1. 提高可读性：用有意义的名称代替复杂类型
2. 增强可维护性：修改类型只需改一处定义
3. 实现封装：通过不透明指针隐藏实现细节
4. 简化复杂声明：特别是函数指针和嵌套类型
5. 平台抽象：编写可移植代码

何时使用typedef

• ✅ 复杂类型（函数指针、嵌套结构）
• ✅ 需要信息隐藏时（不透明指针）
• ✅ 提高代码表达性时
• ✅ 创建领域特定语言时
• ❌ 简单的内置类型（除非有特殊原因）
• ❌ 会使代码更难理解时

记住的原则

1. typedef是别名，不是新类型：编译器视作同一类型
2. 优先使用结构标签：typedef struct Name Name;
3. 保持一致性：项目中使用统一的typedef约定
4. 文档化复杂typedef：特别是函数指针类型

通过合理使用typedef，可以让C代码更清晰、更安全、更易维护，充分发挥C语言的强大能力。

版权所有

版权归属：sumjess

许可证：署名 4.0 国际 (CC-BY-4.0)

上一页03.内存段详解：.text、.data、.bss、.rodata

下一页05.回调函数详解