详细介绍 C 语言 typedef 及与 #define 的核心对比

typedef 是 C 语言的关键字，作用是为现有数据类型创建别名，属于编译阶段的类型处理；而 #define 是预处理指令，核心是文本替换，两者功能和底层机制差异显著。

一、 typedef 核心用法

typedef 的本质是类型重命名，不创造新类型，仅简化复杂类型的书写，提升代码可读性。

基本类型别名

简化基础数据类型的书写，尤其适合跨平台代码（不同平台的 int 长度可能不同）。

c 复制代码

  
#include <stdio.h>
// 为 int 起别名 Int
typedef int Int;
// 为 unsigned int 起别名 UInt
typedef unsigned int UInt;

int main() {
    Int a = 10;
    UInt b = 20U;
    printf("a = %d, b = %u\n", a, b);
    return 0;
}

数组类型别名

简化数组类型的定义，避免重复书写数组长度和元素类型。

c 复制代码

  
#include <stdio.h>
// 为 int[5] 数组类型起别名 IntArr5
typedef int IntArr5[5];

int main() {
    // 等价于 int arr[5] = {1,2,3,4,5};
    IntArr5 arr = {1,2,3,4,5};
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

指针类型别名

重点用于简化复杂指针类型（如数组指针、函数指针），避免优先级混淆。

c 复制代码

  
#include <stdio.h>
// 为 "指向 int 的指针" 起别名 IntPtr
typedef int* IntPtr;
// 为 "指向 int[5] 数组的指针" 起别名 IntArr5Ptr
typedef int (*IntArr5Ptr)[5];

int main() {
    int num = 100;
    IntPtr p = &num;
    printf("*p = %d\n", *p); // 输出 100

    int arr[5] = {1,2,3,4,5};
    IntArr5Ptr p_arr = &arr;
    printf("(*p_arr)[0] = %d\n", (*p_arr)[0]); // 输出 1
    return 0;
}

结构体/枚举类型别名

消除结构体定义时的 struct 关键字，简化代码。

c 复制代码

  
#include <stdio.h>
// 方式1：定义结构体同时起别名
typedef struct {
    char name[20];
    int age;
} Person;

// 方式2：先定义结构体，再起别名
struct Student {
    char id[10];
    float score;
};
typedef struct Student Stu;

int main() {
    Person p = {"Alice", 25};
    Stu s = {"001", 95.5};
    printf("Name: %s, Age: %d\n", p.name, p.age);
    printf("ID: %s, Score: %.1f\n", s.id, s.score);
    return 0;
}

函数指针类型别名

这是 typedef 最实用的场景之一，大幅简化函数指针的定义和使用。

c 复制代码

  
#include <stdio.h>
// 定义函数类型：参数为 int, int，返回值为 int
typedef int (*CalcFunc)(int, int);

// 加法函数
int add(int a, int b) {
    return a + b;
}
// 乘法函数
int mul(int a, int b) {
    return a * b;
}

int main() {
    CalcFunc func = add;
    printf("add: %d\n", func(3, 4)); // 输出 7

    func = mul;
    printf("mul: %d\n", func(3, 4)); // 输出 12
    return 0;
}

二、 typedef 与 #define 的核心对比

特性维度	typedef（类型别名）	带参宏（`#define`）
本质属性	关键字，用于为已有类型定义别名（不创造新类型）	预处理指令，用于文本替换（不创造任何实体）
处理阶段	编译阶段（编译器处理）	预处理阶段（早于编译，仅做文本展开）
作用对象	只能作用于数据类型（如 `int`、`struct` 等）	可作用于任何文本（常量、表达式、代码段等）
类型检查	有类型关联，编译器会严格校验类型兼容性	无类型检查，纯文本替换，易隐含类型错误
作用域	遵循变量作用域规则（局部/全局，块级有效）	从定义处到文件结尾，可用 `#undef` 显式终止
指针/数组处理	精准处理复杂类型，避免优先级陷阱（如 `typedef int* PINT; PINT a,b;` 中 a、b 均为指针）	文本替换易引发优先级问题，需手动加括号（如 `#define PINT int; PINT a,b;` 等价于 `int a, b;`，仅 a 是指针）
是否创造新类型	不创造新类型，仅为已有类型起别名	不创造任何东西，仅做文本替换
与指针结合的陷阱	`typedef int* PINT; PINT a, b;` 中 a、b 均为 `int*` 指针	`#define PINT int; PINT a, b;` 等价于 `int a, b;`（仅 a 是指针，b 是 int）

典型陷阱对比示例

指针别名的差异

c 复制代码

  
#include <stdio.h>

// typedef 版本：a 和 b 都是 int* 类型
typedef int* IntPtr_typedef;
// #define 版本：纯文本替换
#define IntPtr_define int*

int main() {
    int x = 10, y = 20;
    // 正确：a、b 均为 int*
    IntPtr_typedef a = &x, b = &y;
    // 陷阱：等价于 int* c, d; → c 是 int*，d 是 int
    IntPtr_define c = &x, d = &y;

    printf("*a = %d, *b = %d\n", *a, *b); // 输出 10 20
    printf("*c = %d\n", *c); // 输出 10
    // printf("*d = %d\n", *d); // 错误：d 是 int 变量，未初始化
    return 0;
}

数组类型的差异

c 复制代码

  
#include <stdio.h>

// typedef：为 int[5] 起别名 IntArr5
typedef int IntArr5[5];
// #define：文本替换 "int[5]"
#define IntArr5_define int[5]

int main() {
    // 正确：arr1 是 int[5] 数组
    IntArr5 arr1 = {1,2,3,4,5};
    // 错误：预处理后为 int[5] arr2; 语法不合法
    // IntArr5_define arr2 = {1,2,3,4,5};
    return 0;
}

三、总结

typedef 适用于类型简化：尤其适合复杂指针、数组、结构体类型，有类型检查，不易出错。
#define 适用于文本替换：适合定义常量、代码片段、条件编译，无类型检查，需注意优先级和陷阱。
核心选择原则：

若要简化类型书写，用 typedef ；
若要做通用文本替换，用 #define 。