typedef trong C: đặt tên kiểu, typedef struct và khi nào không nên dùng

typedef làm một việc nhỏ: đặt thêm một tên cho một kiểu đã tồn tại. Không có kiểu mới nào được tạo, không có bộ nhớ nào được dành ra, và cách giá trị hoạt động không thay đổi gì. Đây là công cụ đặt tên, và trong C, nơi tên các kiểu dựng sẵn khá dài (unsigned long long, struct Employee, void (*)(int)), một cái tên tốt rất đáng giá.

Dạng cơ bản

Cú pháp đọc giống như khai báo biến có gắn thêm typedef ở đầu. Ở chỗ lẽ ra là tên biến, bạn đặt tên kiểu mới:

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

Đó là toàn bộ quy tắc, và nó giải thích mọi typedef bạn sẽ đọc, kể cả những dạng trông kỳ lạ ở phần sau của trang này.

#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;
}

Hãy để ý điều mà cặp Celsius/Fahrenheit không mang lại: an toàn kiểu. Cả hai đều chỉ là double, nên truyền một giá trị Fahrenheit vào chỗ cần Celsius vẫn biên dịch bình thường. Các tên này thể hiện ý định cho người đọc; chúng không tạo ra bước kiểm tra nào.

Mẫu typedef struct

Đây là lý do phần lớn chương trình C có dùng typedef. Trong C, tên kiểu của một struct bao gồm cả từ khóa:

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

Một typedef rút gọn điều đó:

#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;
}

Đọc nó theo quy tắc ở trên: bỏ typedef đi, bạn có struct Point {...} Point;, khai báo một biến tên là Point. Thêm typedef trở lại thì Point trở thành tên kiểu.

Có tag hay không có tag

Bạn có thể bỏ hẳn tag, tạo ra một struct ẩn danh chỉ có tên typedef:

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

Cách này gọn hơn, và với một bản ghi dữ liệu đơn giản thì đây là phong cách phổ biến. Nhưng nó thất bại ngay khi struct cần nhắc tới chính nó, vì tên typedef chưa dùng được cho đến khi khai báo của chính nó kết thúc:

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

Giữ lại tag thì việc tự tham chiếu hoạt động, vì struct Node dùng được ngay khi tag xuất hiện:

#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;
}

Quy tắc thực tế: giữ lại tag. Nó chỉ tốn một từ, trùng với tên typedef nên không gây nhầm lẫn, và vẫn cho phép tự tham chiếu cũng như khai báo trước trong tệp header. Xem trang struct và con trỏ để biết nút liên kết đó phát triển thành gì.

Khai báo trước và kiểu opaque

Vì con trỏ tới struct có kích thước xác định ngay cả khi chưa biết nội dung struct, một tệp header có thể cung cấp một kiểu mà không để lộ các thành viên:

/* 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);

Định nghĩa đầy đủ struct Stack { ... }; nằm trong stack.c và không ai bên ngoài đụng được vào các thành viên của nó. Mẫu kiểu opaque này là cách các thư viện C đảm bảo tính đóng gói, và đó chính xác là FILE trong thư viện chuẩn: bạn nhận một FILE * từ fopen mà không được biết gì về bên trong nó. Xem xử lý tệp.

typedef cho enum và union

Cùng mẫu đó áp dụng cho hai loại kiểu phức hợp còn lại:

#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;
}

Không có typedef, chúng sẽ là enum Color c; và union Number n;. Xem enum và union để biết chúng thực sự làm gì.

typedef cho con trỏ hàm

Đây là chỗ typedef không còn chỉ là tiện lợi mà gần như trở nên cần thiết. Cú pháp gốc của con trỏ hàm nổi tiếng là khó đọc:

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

Đặt tên kiểu một lần và cả hai trở nên dễ đọc:

#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;
}

Áp dụng lại quy tắc bỏ typedef: chỉ riêng int (*IntBinaryOp)(int, int); sẽ khai báo một biến tên IntBinaryOp trỏ tới một hàm nhận hai số int và trả về một int. Có typedef, đó trở thành tên kiểu. Xem thêm ở trang con trỏ hàm.

typedef và #define

Với các bí danh đơn giản chúng trông có vẻ thay thế được cho nhau, nhưng thực ra không:

#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 là phép thay thế văn bản mù quáng thực hiện trước khi trình biên dịch nhìn thấy code; typedef là một khai báo thật mà trình biên dịch hiểu, và nó áp dụng cho mọi tên trong danh sách. Hãy dùng typedef cho kiểu và để dành #define cho hằng số và macro.

Khi typedef gây hại

Typedef cũng có thể che giấu thông tin mà người đọc cần. Ví dụ rõ nhất là giấu một con trỏ:

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

NodeRef n = get_node();

Nhìn NodeRef n, người đọc không biết n có thể là NULL không, có phải free không, n và bản sao của nó có dùng chung một đối tượng không, hay các thành viên được truy cập bằng . hoặc ->. Cả bốn câu hỏi đều được trả lời ngay lập tức với struct Node *n.

Thư viện chuẩn cũng đồng ý: nó typedef struct (FILE) và để dấu sao ở chỗ sử dụng (FILE *fp). Từ đó rút ra hai nguyên tắc hợp lý:

• Nên typedef struct, union, enum và con trỏ hàm: phần rườm rà bị loại bỏ không mang thông tin gì.
• Không nên typedef một con trỏ chỉ để viết ngắn hơn, và không typedef một kiểu cơ bản để ngụy trang nó (typedef int Boolean; mời gọi ai đó lưu 7 vào đó; hãy dùng bool trong <stdbool.h>, được trình bày ở trang boolean).

Chính các tên có độ rộng cố định của thư viện chuẩn trong <stdint.h> (uint32_t, int64_t, size_t) đều là typedef, và chúng là lý lẽ tốt nhất ủng hộ tính năng này: chúng nói rõ chúng là gì, chúng khả chuyển, và không có gì bị che giấu.