C 语言 typedef：类型别名、typedef struct 与何时不用

typedef 只做一件小事：给已经存在的类型起另一个名字。它不会创建新类型，不会分配内存，也不会改变值的任何行为。它是一个命名工具，而在 C 中，内置类型名往往很长（unsigned long long、struct Employee、void (*)(int)），一个好名字价值不菲。

基本形式

它的语法读起来就像在变量声明前面加上了 typedef。原本写变量名的位置，换成新的类型名：

unsigned long  count;    // declares a variable named count
typedef unsigned long  ulong;   // declares a TYPE named ulong

规则就这么一条，而它能解释你会读到的所有 typedef，包括本页后面那些看起来很奇怪的。

#include <stdio.h>

typedef unsigned long ulong;
typedef double Celsius;
typedef double Fahrenheit;

Fahrenheit to_f(Celsius c) {
    return c * 9.0 / 5.0 + 32.0;
}

int main(void) {
    ulong big = 4000000000UL;
    Celsius body = 37.0;

    printf("%lu\n", big);
    printf("%.1fC = %.1fF\n", body, to_f(body));
    return 0;
}

注意 Celsius/Fahrenheit 这一对没有带来什么：类型安全。两者都只是 double，所以在需要摄氏度的地方传入华氏度的值，照样能顺利编译。这些名字是写给人看的，用来说明意图，并不会产生任何检查。

typedef struct 写法

大多数 C 程序之所以会出现 typedef，就是因为它。在 C 中，结构体的类型名包含关键字：

struct Point { int x; int y; };
struct Point p;              /* the word "struct" every single time */

typedef 能把它简化：

#include <stdio.h>

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

Point midpoint(Point a, Point b) {
    Point m = {(a.x + b.x) / 2, (a.y + b.y) / 2};
    return m;
}

int main(void) {
    Point a = {0, 0};
    Point b = {10, 6};
    Point m = midpoint(a, b);

    printf("midpoint: (%d, %d)\n", m.x, m.y);
    return 0;
}

用前面的规则来读：去掉 typedef，得到的是 struct Point {...} Point;，即声明一个名为 Point 的变量。把 typedef 加回去，Point 就变成了类型名。

带标签还是不带标签

你可以完全省略标签，得到一个只有 typedef 名字的匿名结构体：

typedef struct {
    int x;
    int y;
} Point;          /* no "struct Point" exists - only "Point" */

这样更简洁，对于普通的数据记录，这是常见的写法。但一旦结构体需要提到自身，它就行不通了，因为 typedef 名字要等它自己的声明结束后才能使用：

/* Does NOT compile: "Node" is not a type yet inside its own braces. */
typedef struct {
    int value;
    Node *next;
} Node;

保留标签，自引用就能工作，因为一看到标签，struct Node 就可以使用了：

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int value;
    struct Node *next;     /* the TAG, not the typedef name */
} Node;

int main(void) {
    Node *head = malloc(sizeof *head);
    Node *second = malloc(sizeof *second);
    if (head == NULL || second == NULL) {
        free(head);
        free(second);
        return 1;
    }

    head->value = 1;
    head->next = second;
    second->value = 2;
    second->next = NULL;

    for (Node *n = head; n != NULL; n = n->next) {
        printf("%d ", n->value);
    }
    printf("\n");

    free(second);
    free(head);
    return 0;
}

实用规则：保留标签。它只多一个词，和 typedef 名字一致所以不会造成混淆，而且为自引用和头文件中的前向声明留了余地。这个链表节点后来能发展成什么，请看结构体与指针一页。

前向声明与不透明类型

因为即使不知道结构体的内容，指向它的指针大小也是已知的，所以头文件可以只交出一个类型，而不暴露它的成员：

/* stack.h */
typedef struct Stack Stack;     /* declared, not defined */

Stack *stack_create(void);
void   stack_push(Stack *s, int value);
int    stack_pop(Stack *s);
void   stack_destroy(Stack *s);

完整的 struct Stack { ... }; 放在 stack.c 中，外部任何代码都无法访问它的成员。这种不透明类型模式是 C 库实现封装的方式，标准库中的 FILE 正是如此：你从 fopen 拿到一个 FILE *，却对它内部是什么一无所知。见文件操作。

枚举和联合体的 typedef

同样的写法也适用于另外两种复合类型：

#include <stdio.h>

typedef enum Color {
    RED,
    GREEN,
    BLUE
} Color;

typedef union Number {
    int i;
    float f;
} Number;

int main(void) {
    Color c = GREEN;
    Number n;
    n.i = 42;

    printf("color = %d, number = %d\n", c, n.i);
    return 0;
}

没有 typedef，它们就得写成 enum Color c; 和 union Number n;。它们的实际用途，请看枚举和联合体。

函数指针的 typedef

到了这里，typedef 就不只是图方便，而几乎是必需的了。函数指针的原始语法出了名地难读：

void (*handler)(int, const char *);        /* a variable */
void register_cb(void (*cb)(int, const char *));   /* a parameter */

给类型起一次名字，两者就都变得易读了：

#include <stdio.h>

typedef int (*IntBinaryOp)(int, int);

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

int apply(IntBinaryOp op, int a, int b) {
    return op(a, b);
}

int main(void) {
    IntBinaryOp ops[] = {add, mul};
    const char *names[] = {"add", "mul"};

    for (int i = 0; i < 2; i++) {
        printf("%s(3, 4) = %d\n", names[i], apply(ops[i], 3, 4));
    }
    return 0;
}

再用一次去掉 typedef 的规则：单独的 int (*IntBinaryOp)(int, int); 会声明一个名为 IntBinaryOp 的变量，它指向一个接收两个 int、返回 int 的函数。加上 typedef，它就成了类型名。更多内容见函数指针一页。

typedef 与 #define

对于简单的别名，它们看起来可以互换，其实不然：

#define INT_PTR int *
typedef int *int_ptr;

INT_PTR  a, b;    /* expands to: int *a, b;  -- b is a plain int! */
int_ptr  c, d;    /* both c and d are int *          */

#define 是在编译器看到代码之前进行的盲目文本替换；typedef 是编译器能理解的真正声明，并且作用于列表中的每个名字。类型用 typedef，#define 留给常量和宏。

typedef 帮倒忙的时候

typedef 也可能隐藏读者需要的信息。最典型的例子就是隐藏指针：

typedef struct Node *NodeRef;    /* the star disappears */

NodeRef n = get_node();

看到 NodeRef n，读者无法判断 n 是否可能为 NULL、是否需要释放、n 和它的副本是否共享同一个对象，以及成员要用 . 还是 -> 访问。而 struct Node *n 能立刻回答这四个问题。

标准库也是这么做的：它 typedef 了结构体（FILE），而把星号留在使用的地方（FILE *fp）。由此可以得出两条合理的准则：

• 应该 typedef 结构体、联合体、枚举和函数指针：去掉的那些冗余不携带任何信息。
• 不要只为了缩短而 typedef 指针，也不要 typedef 基本类型来伪装它（typedef int Boolean; 会诱使别人往里面存 7，应该用 <stdbool.h> 中的 bool，见布尔值）。

标准库自己在 <stdint.h> 中的定宽类型名（uint32_t、int64_t、size_t）全都是 typedef，它们是这个特性最好的证明：名字准确说明了它们是什么，可移植，而且什么也没有隐藏。