附录：C 语言与系统编程核心概念速查表

void foo(int x[4]);   /* 编译器立即转换成： */
void foo(int *x);

char s[6] = "hello";   /* 等价于： */
char s[6] = { 'h', 'e', 'l', 'l', 'o', '\0' };

#include <stdint.h>
int8_t   /*  8 位有符号 */   uint8_t  /*  8 位无符号 */
int16_t  /* 16 位有符号 */   uint16_t /* 16 位无符号 */
int32_t  /* 32 位有符号 */   uint32_t /* 32 位无符号 */
int64_t  /* 64 位有符号 */   uint64_t /* 64 位无符号 */
intptr_t /* 能装下一个指针的整数 */

/* ① 解引用与乘法用同一个符号，靠上下文区分 */
int *A, *B;
int c = (*A) * (*B);      /* 正确、可读 */
int c = *A**B;            /* 能编译，但没人读得懂 —— 别这么写 */

/* ② 后缀 ++ 与 * 的优先级 */
int arr[3] = {1, 2, 3};
int *p = arr;
int x = *p++;             /* 等价于 *(p++)：先取 *p=1，再 p 后移 → x=1, p 指向 arr[1] */
int y = (*p)++;           /* 取 arr[1] 的值 2，再让 arr[1] 变成 3 → y=2, arr[1]=3 */

/* ③ 赋值运算符优先级极低 */
if (a = b) { }            /* 编译通过（除非 -Werror 拦下）：这是赋值，不是比较！ */
if (a == b) { }           /* 正确写法 */
if (3 == a) { }           /* "Yoda 写法"：写错成 3 = a 会直接编译报错 */

x & (1 << n)          /* 测试第 n 位是否为 1 */
x |= (1 << n)         /* 置第 n 位为 1 */
x &= ~(1 << n)        /* 清第 n 位为 0 */
x ^= (1 << n)         /* 翻转第 n 位 */
(x >> n) & 1          /* 取出第 n 位 */
x & 0xFFFF            /* 取低 16 位 */
x & (x - 1)           /* 清除最低位的 1（用于判断 2 的幂） */
(x & (x - 1)) == 0    /* x 是 2 的幂（x != 0） */

int   v = 42;
int  *p = &v;      /* p 的类型是 int*，值是 v 的地址 */
int **q = &p;      /* q 的类型是 int**，值是 p 的地址 */

*p        /* 解引用：得到 v 的值 42 */
&v        /* 取地址：得到 v 的地址（类型 int*） */
**q       /* 等价于 *p，即 v 的值 */
q         /* p 的地址 */

int  * p;      /* p 是一个指针，指向 int */
int ** p;      /* p 是一个指针，指向（指向 int 的指针） */
char * p;      /* p 是一个指针，指向 char */

int *A, B;     /* A 是 int*，但 B 是 int ！！ */
int *A, *B;    /* 两个都是 int* —— 想声明多个指针必须每个都写 * */

int *p;        /* 只为 p 分配 8 字节，p 未初始化（野指针！） */
int  v;        /* 现在有了一个 int 供 p 指向 */
p = &v;        /* 让 p 指向它 */
*p = 42;       /* 安全地写入 */

int *p = NULL;         /* 空指针：明确表示"不指向任何东西" */
if (p != NULL) { ... } /* 解引用前必须检查 */
if (p) { ... }         /* 等价写法：NULL 在布尔上下文中为假 */

void swap(int32_t *a, int32_t *b)
{
    int32_t tmp = *a;
    *a = *b;
    *b = tmp;
}

/* 调用：swap(&x, &y); —— 必须传地址，因为 C 是传值调用 */

/* 模板：分配成功时把新指针写回调用者 */
int32_t alloc_buffer(uint8_t **out, size_t n)
{
    uint8_t *p = malloc(n);
    if (p == NULL) {
        return -1;         /* 失败：不修改 *out，调用者的指针保持原样 */
    }
    *out = p;              /* 成功：写回 */
    return 0;
}

/* 调用 */
uint8_t *buf = NULL;
if (alloc_buffer(&buf, 1024) != 0) {
    fprintf(stderr, "allocation failed\n");
}

/* ❌ 错误：realloc 失败返回 NULL，原指针被覆盖，内存泄漏 */
p = realloc(p, new_size);

/* ✅ 正确：用临时指针接住返回值 */
void *tmp = realloc(p, new_size);
if (tmp == NULL) {
    /* 原内存 p 仍然有效，可以继续使用或在这里 free */
    free(p);
    return -1;
}
p = tmp;

int region[20];    /* 编译器分配 20 个连续 int，名为 region[0] … region[19] */

int arr[5];
int *p = arr;

p + 1     /* 地址增加 sizeof(int) = 4 字节，不是 1 字节 */
p + 5     /* 增加 5 × 4 = 20 字节 */

/* 一般规则：ptr + n 的新地址 = (char *)ptr + n * sizeof(*ptr) */

int arr[5] = {10, 20, 30, 40, 50};

/* 写法 1：下标 */
for (int i = 0; i < 5; i++) { printf("%d ", arr[i]); }

/* 写法 2：指针 + 偏移 */
for (int i = 0; i < 5; i++) { printf("%d ", *(arr + i)); }

/* 写法 3：移动指针（推荐，最贴近机器） */
for (int *p = arr; p < arr + 5; p++) { printf("%d ", *p); }

void f(int arr[10])
{
    /* ⚠️ 参数已退化为 int*，这里的 sizeof 是指针大小！ */
    size_t n = sizeof(arr);        /* 8，不是 40 */
    size_t m = sizeof(arr) / sizeof(arr[0]);  /* 8/4 = 2，完全错误！ */
}

int main(void)
{
    int arr[10];
    size_t n = sizeof(arr) / sizeof(arr[0]);  /* 40/4 = 10 ✅ 只在定义所在的函数里有效 */
    f(arr);    /* 必须另行传长度：改为 f(arr, 10) */
    return 0;
}

void f(int32_t *arr, size_t n)
{
    for (size_t i = 0; i < n; i++) { /* ... */ }
}

int m[3][4];    /* 3 行 4 列，共 12 个 int，连续存放 */

/* 元素 m[i][j] 的地址公式： */
/*   base + (i * 4 + j) * sizeof(int)     ← 注意 4 是列数 */

int  m1[3][4];      /* 真正的二维数组：12 个 int 连续存放，共 48 字节 */
int *m2[3];         /* 3 个指针的数组，共 24 字节，每行可指向不同长度的内存（锯齿表） */
int (*m3)[4];       /* 一个指针，指向"含 4 个 int 的数组"，步长 16 字节 */

int  *m2[3];    /* m2 先与 [3] 结合 → m2 是数组；元素类型是 int* */
int (*m3)[4];   /* 括号强制 m3 先与 * 结合 → m3 是指针；指向 int[4] */
int *f(void);   /* f 先与 () 结合 → f 是函数；返回 int* */
int (*f)(void); /* 括号强制 f 先与 * 结合 → f 是指针；指向"返回 int 的函数" */

char s1[] = "hello";        /* 数组：6 字节（含 '\0'），可修改 */
char *s2  = "hello";        /* 指针：只占 8 字节，指向静态存储区的只读字面量 */

/* 模板：安全复制（自己检查长度） */
int32_t safe_copy(char *dst, size_t dst_size, const char *src)
{
    size_t need = strlen(src) + 1;    /* +1 给 NUL */
    if (need > dst_size) {
        return -1;                    /* 目标太小，拒绝复制 */
    }
    memcpy(dst, src, need);
    return 0;
}

/* 模板：用 snprintf 做有界格式化（最省心的安全拼接） */
char buf[64];
int n = snprintf(buf, sizeof(buf), "value=%d, name=%s", v, name);
if (n < 0 || (size_t)n >= sizeof(buf)) {
    /* 被截断了 */
}

if (strcmp(a, b) == 0) { /* 相等 */ }
if (strcmp(a, b) <  0) { /* a 在字典序上小于 b */ }
if (strcmp(a, b) != 0) { /* 不等 */ }

/* ❌ 常见错误：这样比较的是两个指针的地址，永远不为 0（字面量可能相同，但不可依赖） */
if (a == b) { }

static int32_t file_counter = 0;   /* 文件作用域：其他文件看不见 */

void f(void)
{
    int32_t local = 0;             /* 函数作用域 */
    {
        int32_t inner = 5;         /* 块作用域：出了这对花括号就消失 */
    }
    /* inner 在这里不存在 */
}

#include <stdio.h>

int32_t g = 1;                 /* static storage duration，整个程序生命周期 */

void counter(void)
{
    static int32_t n = 0;      /* static storage duration，但作用域只在本函数内 */
    n++;
    printf("called %d times\n", n);   /* 每次调用都递增，不会重置 */
}

void f(void)
{
    int32_t local = 5;         /* automatic：每次进入 f 都重新分配 */
}

/* 1. 函数原型（声明）：告诉编译器返回类型和参数类型，不含函数体 */
int32_t max_of(int32_t a, int32_t b);

/* 2. 函数定义：包含函数体 */
int32_t max_of(int32_t a, int32_t b)
{
    return (a > b) ? a : b;
}

/* 3. 无参数的函数：用 (void) 而不是 () */
int32_t get_value(void);   /* ✅ 明确表示不接受参数 */
int32_t get_value();       /* ⚠️ 在 C 中表示"参数未指定"，不是"无参数" */

void try_to_change(int32_t x)   { x = 99; }        /* 改的是副本，调用者不变 */
void really_change(int32_t *px) { *px = 99; }      /* 改的是调用者的变量 */

int main(void)
{
    int32_t v = 1;
    try_to_change(v);        /* v 仍然是 1 */
    really_change(&v);       /* v 变成 99 */
    return 0;
}

/* 下面四种写法在编译器眼里完全一样，全都退化为 int32_t* */
void f(int32_t arr[10]);
void f(int32_t arr[]);
void f(int32_t *arr);
void f(int32_t *arr, size_t n);   /* ✅ 推荐：显式带长度 */

/* 声明一个函数指针 */
int32_t (*cmp)(const void *, const void *);

/* 读法：从 cmp 出发 → 先看 (*cmp) 说明是指针 → 再看 (…) 说明指向函数
        → 返回 int32_t */

/* 赋值：函数名本身就是函数地址 */
cmp = my_compare;      /* ✅ 等价于 cmp = &my_compare; */

/* 调用 */
int32_t r = cmp(&a, &b);        /* ✅ 等价于 (*cmp)(&a, &b); */

/* 常见混淆 */
int32_t  *f(int32_t);           /* f 是函数，返回 int32_t* */
int32_t (*f)(int32_t);          /* f 是指针，指向返回 int32_t 的函数 */
int32_t (*tbl[4])(int32_t);     /* tbl 是数组，每个元素是函数指针（跳转表） */

/* 跳转表：用一个整数索引直接分派到不同函数 */
typedef int32_t (*op_fn)(int32_t, int32_t);

static int32_t op_add(int32_t a, int32_t b) { return a + b; }
static int32_t op_sub(int32_t a, int32_t b) { return a - b; }
static int32_t op_mul(int32_t a, int32_t b) { return a * b; }

static op_fn ops[] = { op_add, op_sub, op_mul };

int32_t dispatch(size_t which, int32_t a, int32_t b)
{
    if (which >= sizeof(ops) / sizeof(ops[0])) {
        return 0;
    }
    return ops[which](a, b);      /* 通过函数指针调用 */
}

printf("%d %s %f\n", i, s, d);
/*      ↑ 第一个参数必须在固定偏移，才能解析出后面三个 */

/* ❌ 未定义行为：返回指向已销毁栈帧的指针 */
int32_t *bad(void)
{
    int32_t local = 42;
    return &local;      /* local 随栈帧销毁而失效 */
}

/* ✅ 正确：用堆分配（调用者负责 free） */
int32_t *good(void)
{
    int32_t *p = malloc(sizeof(int32_t));
    if (p != NULL) {
        *p = 42;
    }
    return p;           /* 调用者必须 free */
}

typedef struct {
    int32_t x;
    int32_t y;
} point_t;

point_t p   = { 3, 4 };
point_t *pp = &p;

p.x        /* 通过结构体变量访问成员 */
pp->x      /* 通过指针访问成员：-> 就是 (*pp).x 的简写 */
(*pp).x    /* 与上一行完全等价 */

typedef struct {
    char a;      /* 偏移 0，1 字节 */
    /* 3 字节填充 */
    int  b;      /* 偏移 4，4 字节 */
    char c;      /* 偏移 8，1 字节 */
    /* 3 字节尾部填充（为了让数组中的下一个元素对齐） */
} padded_t;

/* sizeof(padded_t) == 12，而不是 1+4+1 = 6 */

typedef struct { char a; char c; int b; } packed_t;   /* sizeof == 8 */

/* 课程编码规范要求：定义 struct 和 enum 时总是使用 typedef */
typedef struct {
    float origin_x;
    float origin_y;
    float radius;
} circle;

typedef enum {
    APPLE,
    ORANGE,
    BANANA,
} fruit;

#if !defined(_MEM220_H)
#define _MEM220_H

#include <stdint.h>
#include <stddef.h>

/* 只前向声明，使用者看到的是一个不完整的类型 */
typedef struct memory_system memory_system_t;

memory_system_t *mem220_create(void);
void             mem220_destroy(memory_system_t *ms);
void            *mem220_allocate(memory_system_t *ms, size_t n_bytes);
void             mem220_free(memory_system_t *ms, void *ptr);

#endif /* !defined(_MEM220_H) */

struct memory_system {
    /* 私有表示：使用者完全不知道这些字段的存在 */
    uint8_t *heap_start;
    size_t   total_size;
    /* ... 空闲链表等内部状态 ... */
};

#if !defined(_MYMODULE_H)
#define _MYMODULE_H

#include <stdint.h>
#include <stddef.h>

typedef struct {
    int32_t value;
    char    name[32];
} record_t;

/* 函数声明，每行加注释说明契约 */
int32_t record_init(record_t *rec, const char *name, int32_t value);
void    record_print(const record_t *rec);

#endif /* !defined(_MYMODULE_H) */

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

int main(void)
{
    size_t n = 10;

    /* 1. 分配 */
    int32_t *arr = malloc(n * sizeof(int32_t));
    if (arr == NULL) {                       /* 2. 必须检查 */
        fprintf(stderr, "Out of memory\n");
        return 1;
    }

    /* 3. 使用 */
    for (size_t i = 0; i < n; i++) {
        arr[i] = (int32_t)(i * i);
    }

    /* 4. 释放 */
    free(arr);
    arr = NULL;                              /* 5. 置 NULL，防止悬垂指针 */

    return 0;
}

int32_t *a = malloc(10 * sizeof(int32_t));       /* ✅ 推荐：显式类型 */
int32_t *b = malloc(10 * sizeof(*b));            /* ✅ 也推荐：改类型时自动跟着变 */
int32_t *c = malloc(10 * sizeof(int));           /* ⚠️ 在本平台上恰好对，但不通用 */
int32_t *d = malloc(10 * 4);                     /* ❌ 魔法数字，禁止 */

typedef struct {
    int32_t *data;
    size_t   count;
    size_t   capacity;
} vec_t;

int32_t vec_push(vec_t *v, int32_t value)
{
    if (v->count == v->capacity) {
        size_t new_cap = (v->capacity == 0) ? 4 : v->capacity * 2;
        int32_t *tmp = realloc(v->data, new_cap * sizeof(int32_t));
        if (tmp == NULL) {
            return -1;                 /* 原数据完好，调用者可继续使用 */
        }
        v->data     = tmp;
        v->capacity = new_cap;
    }
    v->data[v->count++] = value;
    return 0;
}

#include <unistd.h>
void *sbrk(intptr_t increment);

typedef struct node {
    int32_t      value;
    struct node *next;      /* 自引用：必须是指针，不能是 struct node */
} node_t;

for (node_t *p = head; p != NULL; p = p->next) {
    /* 处理 p->value */
}

node_t *push_front(node_t *head, int32_t value)
{
    node_t *n = malloc(sizeof(node_t));
    if (n == NULL) {
        return head;            /* 失败：返回原链表 */
    }
    n->value = value;
    n->next  = head;
    return n;                   /* 新头 */
}

int32_t list_remove(node_t **head, int32_t value)
{
    node_t **link = head;               /* link 指向"指向当前节点的指针" */
    while (*link != NULL) {
        if ((*link)->value == value) {
            node_t *victim = *link;
            *link = victim->next;       /* 让前驱（或 head）跳过它 */
            free(victim);
            return 0;
        }
        link = &(*link)->next;
    }
    return -1;                          /* 未找到 */
}

void list_destroy(node_t *head)
{
    while (head != NULL) {
        node_t *next = head->next;      /* ⚠️ 必须先保存！ */
        free(head);
        head = next;
    }
}

typedef struct tree_node {
    int32_t          value;
    struct tree_node *left;
    struct tree_node *right;
} tree_node_t;

void inorder(const tree_node_t *root)
{
    if (root == NULL) {          /* 基本情况：空树 */
        return;
    }
    inorder(root->left);
    printf("%d ", root->value);
    inorder(root->right);
}

void tree_destroy(tree_node_t *root)
{
    if (root == NULL) {
        return;
    }
    tree_destroy(root->left);    /* 必须先释放子树 */
    tree_destroy(root->right);
    free(root);                  /* 最后释放自己（后序） */
}

const tree_node_t *bst_find(const tree_node_t *root, int32_t key)
{
    while (root != NULL) {
        if (key == root->value) { return root; }
        root = (key < root->value) ? root->left : root->right;
    }
    return NULL;
}

int32_t factorial(int32_t n)
{
    if (n <= 1) {              /* 基本情况 */
        return 1;
    }
    return n * factorial(n - 1);   /* 递归情况 */
}

/* 尾递归形式：把累积量作为参数传下去 */
int32_t fact_tail(int32_t n, int32_t acc)
{
    if (n <= 1) {
        return acc;
    }
    return fact_tail(n - 1, n * acc);   /* 递归调用是最后一步 */
}

/*
 * 通用回溯模板：
 *   1. 判断是否已经找到解 / 走不通 → 返回
 *   2. 标记当前位置（做选择）
 *   3. 递归探索所有邻居
 *   4. 撤销标记（回溯）
 */
int32_t solve(grid_t *g, int32_t r, int32_t c)
{
    /* 越界或已访问或不可通行 */
    if (r < 0 || r >= g->rows || c < 0 || c >= g->cols) { return 0; }
    if (g->cell[r][c] != OPEN)                          { return 0; }

    /* 到达目标 */
    if (r == g->goal_r && c == g->goal_c)               { return 1; }

    g->cell[r][c] = VISITED;        /* 做选择：标记 */

    /* 探索四个方向 */
    if (solve(g, r + 1, c) || solve(g, r - 1, c) ||
        solve(g, r, c + 1) || solve(g, r, c - 1)) {
        return 1;                   /* 找到解，逐层返回 */
    }

    g->cell[r][c] = OPEN;           /* 撤销选择：回溯 */
    return 0;
}

int32_t fib(int32_t n)
{
    if (n < 2) { return n; }
    return fib(n - 1) + fib(n - 2);
}

void insertion_sort(int32_t *a, size_t n)
{
    for (size_t i = 1; i < n; i++) {
        int32_t key = a[i];        /* 取出待插入的元素 */
        size_t  j   = i;
        while (j > 0 && a[j - 1] > key) {
            a[j] = a[j - 1];       /* 更大的元素整体右移一格 */
            j--;
        }
        a[j] = key;                /* 插到正确位置 */
    }
}

static void merge(int32_t *a, int32_t *tmp, size_t lo, size_t mid, size_t hi)
{
    size_t i = lo, j = mid, k = lo;

    while (i < mid && j < hi) {
        /* 用 <= 保证稳定性：相等时优先取左边的 */
        tmp[k++] = (a[i] <= a[j]) ? a[i++] : a[j++];
    }
    while (i < mid) { tmp[k++] = a[i++]; }
    while (j < hi)  { tmp[k++] = a[j++]; }

    for (size_t m = lo; m < hi; m++) {
        a[m] = tmp[m];
    }
}

void merge_sort_rec(int32_t *a, int32_t *tmp, size_t lo, size_t hi)
{
    if (hi - lo < 2) {             /* 0 或 1 个元素：已有序 */
        return;
    }
    size_t mid = lo + (hi - lo) / 2;
    merge_sort_rec(a, tmp, lo, mid);
    merge_sort_rec(a, tmp, mid, hi);
    merge(a, tmp, lo, mid, hi);
}

void merge_sort(int32_t *a, size_t n)
{
    int32_t *tmp = malloc(n * sizeof(int32_t));
    if (tmp == NULL) {
        return;                    /* 分配失败：放弃（或回退到插入排序） */
    }
    merge_sort_rec(a, tmp, 0, n);
    free(tmp);
}

static size_t partition(int32_t *a, size_t lo, size_t hi)
{
    /* hi 位置作为主元 */
    int32_t pivot = a[hi];
    size_t  i     = lo;            /* a[lo..i) 都是 <= pivot */

    for (size_t j = lo; j < hi; j++) {
        if (a[j] <= pivot) {
            int32_t t = a[i]; a[i] = a[j]; a[j] = t;
            i++;
        }
    }
    int32_t t = a[i]; a[i] = a[hi]; a[hi] = t;   /* 主元归位 */
    return i;                      /* 主元的最终下标 */
}

void quick_sort_rec(int32_t *a, size_t lo, size_t hi)
{
    if (hi <= lo || hi - lo < 2) {
        return;
    }
    size_t p = partition(a, lo, hi - 1);
    if (p > lo)     { quick_sort_rec(a, lo, p); }
    if (p + 1 < hi) { quick_sort_rec(a, p + 1, hi); }
}

#include <stdlib.h>

/* 比较函数的契约：返回 <0 表示 a 应排在 b 前；0 表示等价；>0 表示 a 应排在 b 后 */
int cmp_int_asc(const void *pa, const void *pb)
{
    int32_t a = *(const int32_t *)pa;
    int32_t b = *(const int32_t *)pb;
    if (a < b) { return -1; }
    if (a > b) { return  1; }
    return 0;
    /* ⚠️ 不要写 return a - b; —— 对 int32_t 可能溢出！ */
}

/* 调用 */
int32_t arr[100];
qsort(arr, 100, sizeof(arr[0]), cmp_int_asc);

typedef struct { char name[32]; int32_t score; } student_t;

static int cmp_by_score(const void *pa, const void *pb)
{
    const student_t *a = pa;
    const student_t *b = pb;
    if (a->score < b->score) { return -1; }
    if (a->score > b->score) { return  1; }
    return strcmp(a->name, b->name);       /* 分数相同时按名字，保证确定性 */
}

qsort(students, n, sizeof(student_t), cmp_by_score);

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

int32_t read_whole_file(const char *path, char **out, size_t *out_len)
{
    FILE *fp = fopen(path, "r");
    if (fp == NULL) {
        perror(path);              /* 打印 "path: No such file or directory" */
        return -1;
    }

    size_t cap  = 4096;
    size_t len  = 0;
    char  *buf  = malloc(cap);
    if (buf == NULL) {
        fclose(fp);
        return -1;
    }

    size_t got;
    while ((got = fread(buf + len, 1, cap - len, fp)) > 0) {
        len += got;
        if (len == cap) {                    /* 缓冲区满了，扩容 */
            char *tmp = realloc(buf, cap * 2);
            if (tmp == NULL) {
                free(buf);
                fclose(fp);
                return -1;
            }
            buf = tmp;
            cap *= 2;
        }
    }

    if (ferror(fp)) {                        /* 区分 EOF 与真错误 */
        free(buf);
        fclose(fp);
        return -1;
    }

    fclose(fp);
    *out     = buf;
    *out_len = len;
    return 0;
}

char line[256];
while (fgets(line, sizeof(line), fp) != NULL) {
    /* 去掉行尾换行 */
    size_t n = strlen(line);
    if (n > 0 && line[n - 1] == '\n') {
        line[n - 1] = '\0';
    } else if (n == sizeof(line) - 1) {
        /* ⚠️ 行太长，缓冲区被填满且没有读到换行 —— 剩余部分还在文件里！
           必须把这一行剩下的字符读掉，否则会被当成下一行。 */
        int c;
        while ((c = fgetc(fp)) != '\n' && c != EOF) { }
    }
    /* 处理 line */
}

/* ❌ 错误写法 */
while (!feof(fp)) {
    fgets(line, sizeof(line), fp);
    printf("%s", line);          /* 最后一次循环会重复打印上一行！ */
}

/* ✅ 正确写法：用读取函数的返回值判断 */
while (fgets(line, sizeof(line), fp) != NULL) {
    printf("%s", line);
}

/* 用 strtok 切分（注意：会破坏原字符串，把分隔符改成 '\0'） */
char *save = NULL;
for (char *tok = strtok_r(line, " \t\n", &save);
     tok != NULL;
     tok = strtok_r(NULL, " \t\n", &save)) {
    /* 处理 tok */
}

/* 用 strtol 安全地把字符串转成整数 */
char *end;
errno = 0;
long v = strtol(tok, &end, 10);
if (end == tok || *end != '\0' || errno == ERANGE) {
    /* 转换失败或溢出 */
}

/* 用 sscanf 从字符串里提取格式化字段（比 strtok 更适合固定格式） */
int y, m, d;
if (sscanf(line, "%d-%d-%d", &y, &m, &d) == 3) {
    /* 成功解析 3 个字段 */
}

int32_t v;
scanf("%d", &v);          /* ✅ scanf 需要地址 */
printf("%d\n", v);        /* ✅ printf 需要值 */
scanf("%d", v);           /* ❌ 漏了 & —— 编译警告，运行时段错误 */

char name[64];
scanf("%s", name);        /* ✅ name 本身就是地址 */
scanf("%s", &name);       /* 类型不同（char(*)[64]）但地址值相同，能跑，不推荐 */

/* ① scanf 的 %c 会匹配空格和换行 —— 这通常不是你要的 */
scanf("%c", &ch);         /* ❌ 可能读到上一行残留的 '\n' */
scanf(" %c", &ch);        /* ✅ 格式串前面加一个空格：跳过所有前导空白 */

/* ② scanf 的 %s 不检查缓冲区大小 —— 缓冲区溢出风险 */
char buf[10];
scanf("%s", buf);                 /* ❌ 输入 "verylongstring" 就溢出了 */
scanf("%9s", buf);                /* ✅ 限制宽度为 sizeof(buf)-1 */

/* ③ scanf 的 %f 对应 float*，但 double 必须用 %lf */
float  f;  scanf("%f",  &f);      /* ✅ */
double d;  scanf("%f",  &d);      /* ❌ 类型不匹配，未定义行为 */
double d;  scanf("%lf", &d);      /* ✅ */

/* printf 返回写入的字符数，负值表示出错 */
int n = printf("value = %d\n", v);
if (n < 0) {
    perror("printf");
}

/* scanf 返回成功赋值的项数，不是字符数！ */
int count = scanf("%d %d", &a, &b);
if (count != 2) {
    /* 可能是输入格式不对，或者提前遇到 EOF */
    fprintf(stderr, "Expected two integers, got %d\n", count);
}

printf("%5d\n",   42);       /* 宽度 5，右对齐："   42" */
printf("%-5d|\n", 42);       /* 左对齐："42   |" */
printf("%05d\n",  42);       /* 补零："00042" */
printf("%.3f\n",  3.14159);  /* 3 位小数："3.142" */
printf("%8.2f\n", 3.14159);  /* 宽度 8，2 位小数："    3.14" */
printf("%x\n",    255);      /* 十六进制："ff" */
printf("%#x\n",   255);      /* 带前缀："0xff" */
printf("%X\n",    255);      /* 大写："FF" */
printf("%e\n",    1234.5);   /* 科学计数法 */
printf("%%\n",    0);        /* 输出一个百分号 */
printf("%zu\n",   sizeof(int)); /* size_t 必须用 %zu */

int32_t a;          /* 局部变量 */
int32_t b = 5;

a = b + c;

if (a < b) {
    x = 1;
} else {
    x = 2;
}

while (i < n) {
    sum += i;
    i++;
}

int32_t arr[5];
int32_t x = arr[2];
arr[3] = 7;

/* 用指针遍历数组（等价形式）*/
for (int32_t *p = arr; p < arr + 5; p++) { sum += *p; }

int32_t r = add3(1, 2, 3);

typedef struct { int32_t x; int32_t y; } point_t;
point_t p;
p.y = 7;

point_t *pp = &p;
int32_t v = pp->y;

/* buggy.c */
#include <stdio.h>
int main(void)
{
    int arr[5] = { 10, 20, 30, 40, 50 };
    int sum = 0;
    for (int i = 0; i <= 5; i++) {      /* ⚠️ 应为 i < 5 */
        sum += arr[i];
    }
    printf("sum = %d\n", sum);
    return 0;
}

/* ❌ 每次循环泄漏一块内存 */
for (int i = 0; i < 1000; i++) {
    int32_t *p = malloc(sizeof(int32_t));
    *p = i;
    /* 忘了 free(p)，而且 p 出了作用域就丢了 —— 这块内存再也找不回来了 */
}

/* ✅ 修复 */
for (int i = 0; i < 1000; i++) {
    int32_t *p = malloc(sizeof(int32_t));
    if (p == NULL) { return -1; }
    *p = i;
    /* ... 使用 p ... */
    free(p);
    p = NULL;
}

/* ❌ 释放后继续使用 */
int32_t *p = malloc(sizeof(int32_t));
*p = 42;
free(p);

printf("%d\n", *p);       /* ❌ use-after-free：内存可能已被重新分配或归还给 OS */
*p = 7;                   /* ❌ 更糟：写坏别人的数据 */

/* ✅ 修复：释放后立刻置 NULL */
free(p);
p = NULL;
/* 之后任何对 p 的解引用都会立即段错误（好过默默破坏数据） */

/* ❌ */
int32_t *p = malloc(sizeof(int32_t));
free(p);
free(p);                  /* ❌ 破坏分配器的空闲链表 */

/* ✅ */
free(p);
p = NULL;
free(p);                  /* ✅ free(NULL) 是合法的空操作 */

int32_t arr[10];

/* ❌ 循环写多了 */
for (int i = 0; i <= 10; i++) { arr[i] = 0; }   /* arr[10] 越界 */

/* ❌ 差一错误 */
int32_t *buf = malloc(10 * sizeof(int32_t));
buf[10] = 1;                                    /* 正好写在块尾之后 */

/* ❌ 返回指向已销毁栈帧的指针 */
int32_t *bad(void)
{
    int32_t local = 42;
    return &local;         /* local 所在栈帧已失效 */
}

/* ✅ 方案 A：调用者提供缓冲区 */
void good_a(int32_t *out) { *out = 42; }

/* ✅ 方案 B：堆分配，调用者负责 free */
int32_t *good_b(void) { int32_t *p = malloc(sizeof *p); if (p) { *p = 42; } return p; }

/* ✅ 方案 C：static 变量（注意：不可重入！） */
int32_t *good_c(void) { static int32_t v; v = 42; return &v; }

int32_t *p = malloc(10 * sizeof(int32_t));
/* malloc 不保证清零！内容可能是任意值 */
printf("%d\n", p[0]);      /* ❌ 读到垃圾值 */

/* ✅ 用 calloc 清零 */
int32_t *q = calloc(10, sizeof(int32_t));
/* q[0..9] 全是 0 */

typedef struct { char a; int b; char c; } s_t;
s_t s;
s.a = 'x'; s.c = 'y';      /* ❌ 忘了 s.b */
fwrite(&s, sizeof(s), 1, fp);   /* 把 b 的垃圾值和填充字节一起写进文件 */

int32_t arr[10];
free(arr);                 /* ❌ arr 在栈上，不是 malloc 来的 */
free(&arr[2]);             /* ❌ 偏移过的指针，元数据位置错误 */