章节地图

三条最常见的查法

十站主线

迷失在某章细节里时，回到这条线问一句：「我学的这个东西，让哪一站不再卡住？」

为什么这条路从 C 出发

工具链选型

和别的页怎么分工

C 标准年表

-std= 怎么选

装与验

gcc / clang 开关全表

程序骨架：三种

退出码

编译期：按原文查

按崩溃现象反查

调试手段：从便宜到贵

十条够用的 gdb 命令

前提是编译时带了 -g，并且调试期用 -O0 或 -Og——高优化级别下变量会被优化掉，gdb 只会告诉你 <optimized out>。

基本类型

要范围常量：<limits.h> 的 INT_MAX / CHAR_BIT、<stdint.h> 的 INT32_MAX / SIZE_MAX、<float.h> 的 DBL_EPSILON。

运算符：优先级从高到低

控制流

printf 说明符

先把尺寸记住

• 在 x86-64 Linux（gcc/clang）上 sizeof 是：char 1、short 2、int 4、long 8、long long 8、float 4、double 8、long double 16、指针 8、size_t 8。
• long 的宽度最不可移植：同样是 64 位系统，Linux 上 long 是 8 字节，Windows 上只有 4 字节。想「确定就是 32 位」就用 <stdint.h> 的 int32_t/uint64_t——名字自带宽度，换平台不变。
• sizeof 的结果类型是 size_t（无符号），打印必须用 %zu；用 %d 打印它是格式不匹配的 UB。它也是「有符号 vs 无符号」那一整类 bug 的源头（见本章「整数提升与隐式转换」卡）。
• 浮点默认选 double 不选 float：double 约 15~16 位有效十进制数字，float 只有约 7 位；printf 传参时 float 还会自动提升成 double，省不下什么。

算术与逻辑：三条反直觉

• 整数除法截断：17/5 得 3 而不是 3.4。要浮点必须先转一个操作数，(double)17/5 得 3.4。
• 除法向零取整，取模的符号跟着被除数（C99 起明确规定）。-17/5 == -3、-17%5 == -2、17/-5 == -3、17%-5 == 2。推论：判奇偶写 n%2 == 1 对负数不成立，要写 n%2 != 0。
• && 与 || 短路：左边已能定胜负时，右边根本不求值。if (a != 0 && side()) 在 a 为 0 时 side() 的调用次数是 0。这正是 if (i < n && a[i] > 0) 这种「先判边界再取值」惯用法安全的原因——两个条件写反顺序就先越界了。
• 三目 cond ? a : b 是表达式不是语句，可以直接嵌在赋值或参数里；但别拿它写多层嵌套，可读性会瞬间崩塌。

整型提升与窄化

• 整型提升：比 int 窄的类型（char、short）参与运算前一律先升成 int。所以 char a = 100, b = 100; a * b 得 10000——是在 int 范围里算的，不会溢出 char。
• 这条根也解释了 ctype.h 的经典坑：在 char 有符号的平台（x86-64 Linux 即是）上，(char)200 是 -56，直接传给 isalpha() 就是个负的 int，属于 UB。正确写法永远是 isalpha((unsigned char)c)。
• 窄化赋值截断高位：int big = 300; unsigned char uc = big; 得到的是 44（300 − 256）。加 -Wconversion 能把这类隐式截断全部揪出来。
• 整数与浮点混合时结果向浮点靠，但转换发生在运算之后才是坑：double avg = sum / n; 若 sum、n 都是整数，先做的是整数除法、小数当场丢掉。必须写成 sum / (double)n，强转其中一个操作数。

三种形态

• for (init; cond; step)：计数循环标配。C99 起可把计数器声明在循环头（for (int i = 0; ...)），作用域仅限循环内——推荐，避免变量泄漏到外面。
• while (cond)：先判断后执行，条件为假一次都不跑；适合「不知道要跑几次、由数据说了算」的场景（读输入、遍历链表）。
• do { ... } while (cond);：先执行后判断，保证至少跑一次——菜单循环、「输错重来」的典型选择。注意结尾有分号。

控制与惯用法

• break 跳出本层循环，continue 直接进入下一轮；嵌套循环里 break 只能跳一层，要跳多层用 goto cleanup 或把内层提成函数。
• 遍历 n 个元素的标准写法是半开区间：for (i = 0; i < n; i++)——写 <= 就是越界。
• 无限循环写 for (;;) 或 while (1)，配 break 退出——服务与事件处理的主循环形态。
• 「边读边判」是 C 循环最常见的形态：while ((c = getchar()) != EOF)、while (fgets(buf, sizeof(buf), fp))——赋值放进条件里，读到头自然结束（下面输入输出几张卡会反复见到）。

数组：长度会在传参时丢掉

• 定义时 int a[5] = {1,2,3}; 剩下两个自动补 0；int a[5] = {0}; 是整个数组清零的惯用法。二维数组 int grid[2][3] 在内存里是一行接一行连续存放的，按行遍历比按列遍历对缓存友好得多。
• 数组名在几乎所有表达式里都退化（decay）成指向首元素的指针，所以 a[i] 本质就是 *(a+i)——下标只是指针算术的语法糖（b[1] 和 1[b] 竟然完全等价）。
• 退化的直接后果：长度当场丢失。int a[5] 在定义它的作用域里 sizeof(a) 是 20，传进 void f(int a[10]) 后函数里 sizeof(a) 只剩 8（一个指针）——所以传数组必须额外传长度 n。形参写成 int a[10] 也骗不了编译器，gcc 会警告 warning: 'sizeof' on array function parameter 'a' will return size of 'int *' [-Wsizeof-array-argument]。
• 唯二不退化的场合是 sizeof(数组) 和 &数组——所以 sizeof(a)/sizeof(a[0]) 求元素个数只在数组本尊所在的作用域里有效。

五段结构逐个看

• 标志：- 左对齐、0 补零、+ 强制显示正号、空格（正数留一空位）、# 加进制前缀（%#x 打出 0xff）。
• 宽度：最少占几列，不足补空格；写 * 则宽度由下一个实参动态传入。
• 精度：对 %f 是小数位数、对 %s 是最多打印几个字符、对 %d 是最少数字位数；同样可写 .* 动态传入。
• 长度：声明实参的真实类型——%ld long、%lld long long、%zu size_t、%hd short。
• 转换：d 有符号、u 无符号、x/o 十六/八进制、f/e/g 浮点（%g 自动挑更短的写法并去尾零）、c 字符、s 串、p 指针、%% 字面百分号。

三件必须知道的事

• printf 是可变参数函数，不检查也不转换类型：用 %d 打 long、用 %s 打整数都是 UB——不是「打印得不对」，而是「什么都可能发生」。
• 唯一的宽容来自默认实参提升：float 传参时自动升为 double，所以 %f 通吃两者——但 scanf 里必须区分 %f 与 %lf。
• 输出分流：正常结果走 stdout（printf），错误与日志走 fprintf(stderr, ...)；拼字符串一律用 snprintf——最多写 size-1 个字符并自动补 '\0'，返回「完整结果本应有的长度」，和缓冲区大小一比就知道有没有被截断。

三条空白规则

• %d/%lf/%s 等大多数转换会先跳过一切空白（空格、Tab、换行）再开始读——所以循环 scanf("%d", &x) 能自然读取用空格或换行分隔的一串数字。
• %c 是例外：不跳空白，读到的就是流里的下一个字节，哪怕是上次残留的换行。想「跳过空白读下一个可见字符」，在格式串里加一个空格：" %c"——格式串中的空白意为「匹配任意多个空白字符」。
• %s 遇空白即停（读不了带空格的内容），且不检查长度——务必限宽 %63s；要读到行尾改用 scanset：%63[^\n]（读取除换行外的一切）。至于被 C11 从标准里删除的 gets()，永远别碰。

返回值与进阶写法

• scanf 返回成功赋值的项数，输入耗尽返回 EOF：scanf("%d %d", &a, &b) == 2 才说明两个都读到了。不检查返回值 = 拿未初始化变量继续算。
• %*s：星号表示匹配但丢弃（跳过一列不要的数据）；%5d：最多消费 5 个数字字符。
• 类型对应比 printf 更严格：float 用 %f、double 必须 %lf、long 用 %ld——scanf 拿到的是指针，没有类型提升兜底。

逐字符读写与 EOF

• getchar()/putchar(c) 一次一个字节；fgetc/fputc 是任意流的版本。「循环 getchar 直到 EOF」就是 Unix 过滤器程序的骨架。
• 接返回值必须用 int：EOF 是个负数常量（通常 -1），char 装不下——用 char c 接，轻则把合法字节 0xFF 误判成结束，重则永远等不到 EOF 死循环。
• 终端里手动制造 EOF：Linux/macOS 按 Ctrl+D，Windows 按 Ctrl+Z 再回车；重定向或管道时读到数据尾自然产生 EOF。

三种缓冲模式

• stderr 不缓冲——错误必须立刻可见；stdout 接终端时行缓冲——攒到 \n 才真正写出；stdout 重定向到文件/管道时全缓冲——攒满一块（常见 4KB）才写。
• 两大灵异现象由此解释：① 不带 \n 的提示语迟迟不出现——加 fflush(stdout) 强制刷出；② 程序崩溃时最后几行 printf「消失」——它们死在缓冲区里没来得及落地，所以调试信息应该走 stderr。
• setvbuf(stdout, NULL, _IONBF, 0) 可整个关掉 stdout 缓冲（调试期常用）。

两步走

• 读行：fgets(buf, sizeof(buf), stdin) 最多读 size-1 个字符并自动补 '\0'，返回 NULL 表示 EOF 或出错。它会保留行尾换行符，惯用一行去掉：buf[strcspn(buf, "\n")] = '\0';
• 解析：sscanf(buf, "%d,%d", &x, &y) 用法与 scanf 相同但作用于字符串，照样检查返回值；纯数字解析用 strtol/strtod 更严格可控。

数字解析为什么用 strtol 而不是 atoi

• atoi("abc") 返回 0，与 atoi("0") 无法区分——完全没有错误报告，溢出还是 UB。
• strtol(str, &end, 10) 什么都告诉你：end == str 说明一个数字都没读到；*end 不是 '\n'/'\0' 说明数字后面跟着垃圾字符；溢出则返回 LONG_MAX/LONG_MIN 并置 errno = ERANGE（超出可表示范围）（errno 是库函数报告「为什么失败」的机制，用它之前必须先 errno = 0——它不是普通全局变量，原因见 07 章「errno：错误码是怎么工作的」）。第三个参数是进制（10、16，或 0 自动识别 0x/0 前缀）。

mode 决定能读还是能写、会不会清空原文件

• "r" 只读，文件不存在就失败；"w" 只写，清空原内容或新建（手滑用 w 打开重要文件 = 当场清零）；"a" 追加，总写到末尾；
• 加 + 变读写："r+" 读写不清空、"w+" 读写但清空、"a+" 读 + 追加写；
• 加 "b" 是二进制模式——Windows 上要紧：文本模式会把 \n ⇄ \r\n 自动翻译，读写二进制务必带 b（"rb"/"wb"）；Linux/macOS 上 b 无区别。

读写与定位

• 文本：fprintf/fscanf 格式化、fgets/fputs 按行；二进制：fwrite/fread 整块读写结构体，返回成功的元素个数，要检查；
• 定位：fseek(fp, off, SEEK_SET/CUR/END) 跳转、ftell 报当前偏移、rewind 回开头；
• fflush(fp) 强制把缓冲写出；stdin/stdout/stderr 本身就是 FILE*，前几张 I/O 卡用的就是它们。

值传递，以及「改不动」的真相

• 形参是实参的副本，函数里改形参调用方一无所知。把 User 结构体按值传进函数改 age，返回后调用方仍是 30；改成传 User * 再改，才真的变成 999。
• 要修改调用方的变量，就传它的地址：void swap(int *a, int *b) 配 swap(&x, &y)。数组看似「例外」，其实不是特例——只是数组名退化成了指针，函数拿到的仍然是一个按值拷贝的指针。
• 多返回值有三条路：传出参指针（int parse(const char *s, long *out)，返回值留给错误码，这是 C 标准库最常见的形态）、返回结构体（整体拷贝，小结构体这样最清爽）、返回 malloc 出来的指针（那就必须约定清楚谁负责 free）。
• 调用前必须先有声明。 gcc 15 默认按 C23 编译，调用未声明的函数已经是硬错误而不再是警告，原文：error: implicit declaration of function 'undeclared' [-Wimplicit-function-declaration]。把原型放进头文件，或至少放在文件顶部。

argc 与 argv 的精确形状

• argc 是参数个数，包含程序名本身；argv[0] 是程序名，真正的参数是 argv[1] 到 argv[argc-1]。
• argv[argc] 标准保证是 NULL—— ./ti a b 得到 argc=3、argv[3] 打印为 (nil)。所以既能按 argc 计数遍历，也能按 NULL 哨兵遍历（execv 这类接口正是靠后者）。
• 参数一律是字符串，哪怕你敲的是数字。要当数字用得自己 strtol/strtod 转，并按本章「健壮读入」那卡的三项检查法验错——命令行参数是外部输入，和用户敲进 stdin 的东西一样不可信。
• 带空格的参数由 shell 负责拆分和去引号，程序侧拿到的已经是干净的一项：./app "hello world" 只占 一个 argv 元素。通配符同理，*.txt 是 shell 先展开成一串文件名才递进来的，不是你的程序去做匹配。

退出码：程序说给 shell 听的那句话

• return 0 表示成功、非 0 表示失败（等价于 exit(0)；<stdlib.h> 另有可移植的 EXIT_SUCCESS/EXIT_FAILURE）。
• shell 用 $? 读它，&& 与 || 的短路、set -e、CI 判定成败全靠它——不认真返回退出码的程序没法被脚本使用（详见 13 章 Shell）。
• 退出码只有低 8 位有效（0~255），别拿它传数据；错误的细节该写到 stderr，退出码只回答「成还是不成」。
• 用法出错时的标准做法：把提示用 fprintf 写到 stderr 再 return 1;——提示走 stderr，这样正常输出被管道接走时提示语不会混进去污染数据。

struct：C 里最常用的自定义类型

• 成员用 . 访问，通过指针用 ->（p->name 就是 (*p).name 的简写）。
• 结构体是值语义：赋值、传参、返回都是整体拷贝。User b = a; 之后改 b.age，a.age 纹丝不动；同理把结构体按值传进函数改字段，调用方看不到任何变化——想让函数改，就传 User *。
• 指定初始化器（C99 起）让初始化不依赖字段顺序、也不怕日后往结构体里加字段：User a = { .age = 30, .name = "Alice" };——顺序写反照样正确，没写到的字段自动清零。
• typedef struct { ... } User; 免去每次写 struct User。但公开 API 里更常见的是 typedef struct User User; 配一个只在 .c 文件里定义的 struct——这就是 C 的不透明指针，用来把实现细节彻底藏起来（标准库的 FILE 正是这么做的）。

声明怎么读

const 的四种组合

指针与数组

动态内存

内存布局与对齐

两个运算符，一进一出

• 把指针想成一张写着门牌号的纸条：纸条本身很小，顺着它才能找到真正的那块内存。& 是写下门牌号(取地址)，* 是照着门牌号去开门(解引用)。两者互为逆操作。
• 指针是有类型的，而类型决定了「开门之后按什么格式读这片字节」。同一个地址，当成 int* 读是 4 个字节一个数，当成 char* 读就是 1 个字节一个数——地址相同，看到的东西完全不同。

指针算术按「格子」走，不按字节走

• p + 1 前进的不是 1 个字节，而是 sizeof(*p) 个字节。拿 int a[10] 验一下：a + 1 与 a 相差 4 字节，正好一个 int。编译器替你把「第几个元素」换算成了地址。
• 这也解释了 const 和 * 的四种组合为什么容易记混——顺着纸条的类比就清楚了：const 在 * 左边锁住的是「门后的东西」(所指数据不可改)，在 * 右边锁住的是「纸条本身」(指针不能改指向别处)。

退化推出的三件事

• a[i] 本质就是 *(a + i)，下标只是指针算术的语法糖。所以 a[3] 和 3[a] 竟然完全等价——两者地址相同。这不是应该写的代码，但它证明了下标运算的真身。
• 把数组传进函数，传的其实是首元素指针，长度当场丢失。同一个 int a[10]：在定义它的作用域里 sizeof a 是 40，传进函数后在函数内 sizeof 只有 8(一个指针的大小)。这就是 C 的函数为什么永远要额外传一个长度参数。
• 唯二不退化的场合是 sizeof(数组) 和 &数组。&a + 1 跨过 40 字节(整个数组)，而 a + 1 只跨 4 字节(一个元素)——同一个 a，加了取地址符含义就全变了。

void* 与 NULL

• void* 是"只有地址、没有类型"的通用指针：它能接收任何对象指针，但不能直接解引用(编译器不知道该读几个字节)，必须先转回具体类型。qsort、memcpy 这类泛型接口全靠它加一个显式的 size 参数来工作。
• NULL 表示"不指向任何对象「，是唯一一个可以安全地用来表达」没有「的指针值。它和」未初始化的野指针"是两回事：NULL 是确定的、可判断的，野指针是随机的。

四个函数各管一件事

• malloc(n) 要 n 字节，内容是未初始化的垃圾；calloc(n, size) 要 n 个元素并全部清零；realloc(p, n) 调整已有块的大小；free(p) 归还。
• 每次分配都必须检查返回值是否为 NULL。这不是形式主义——内存耗尽时它真的会返回 NULL，而不检查就解引用，等于把「内存不够」这个可处理的错误变成了段错误。

高发的五类

• 内存泄漏：malloc 后忘了 free，程序跑得越久占得越多。
• 悬空指针(use-after-free)：free 之后继续用那块内存。
• 缓冲区溢出：写越界，严重时能覆盖函数返回地址——这正是经典栈溢出攻击的原理。
• 重复释放(double-free)：同一块内存 free 两次，会破坏分配器自己的记账数据。
• 返回局部变量地址：函数一返回栈帧就作废，指针指向的内容随时被下一次函数调用覆盖。

它是什么，怎么声明

• 函数名和数组名一样会退化成指向该函数的指针，所以 f、&f 拿到的是同一个东西，调用时写 op(a,b) 或 (*op)(a,b) 也都行——这套「随便怎么写都对」反而是它读起来别扭的原因。
• 声明的形状是 int (*op)(int, int)：括号不能省，省了就变成 int *op(int,int)——一个返回 int* 的函数声明，意思完全不同。实践中一律用 typedef 起个名字，别让这种括号出现在函数签名里。

它能换来什么

• 把「策略」从算法里抽出来：qsort 不知道你要排什么、按什么规则排，它只调用你给的比较函数——同一份排序代码因此能用于任何类型。bsearch、signal 也是同一个套路。
• 函数指针数组 = 跳转表：把一组处理函数按编号放进数组，用 table[cmd](args) 一步派发，替掉又长又慢的 if-else 链。解释器、状态机、命令分发普遍这么写。

为什么是 goto

• 用嵌套 if 处理，代码会被推成金字塔：申请五样资源就缩进五层，而且每个失败分支都要重复写一遍清理，极易漏放或顺序写反。
• 改成"所有出错分支都跳到函数尾部的统一清理段，按与申请相反的顺序逐级回滚"，缩进就平了，清理逻辑只写一份。这是 Linux 内核和大量 C 库通用的错误处理骨架。
• 注意这里的 goto 只向前跳、只跳到函数尾、只做清理——和「面条式跳转」是两回事。受批评的是任意方向的乱跳，不是这种单向的、结构化的用法。

让它不必费心也安全的诀窍

• 所有资源变量先统一初始化为「空值」：指针置 NULL、文件描述符置 -1、FILE* 置 NULL。
• 清理段对每个资源先判空再释放。这样从任意一个失败点跳进来都是安全的——还没申请到的那些资源，此刻仍是空值，会被跳过。不必为每种失败情形各写一个入口。

五个区，各有脾气

• 栈：局部变量与函数参数，向下增长，分配只是移动一个寄存器所以极快，但很小(通常 8 MB 量级)，且函数一返回就作废。
• 堆：malloc 的地盘，向上增长，大小灵活但每次分配都要走分配器的记账逻辑，比栈慢得多。
• BSS：未初始化(或初始化为 0)的全局与静态变量，程序启动时由系统统一清零。
• Data：有非零初值的全局与静态变量，初值必须真的存在可执行文件里。
• Text：机器码与字符串字面量，只读——这就是改字符串字面量会段错误的原因。

两个由此推出的实用结论

• 大数据结构必须放堆上。在函数里写 int buf[1000000] 会直接把栈撑爆(栈溢出通常表现为启动就段错误，且没有任何提示)；同样，递归太深也会栈溢出，这是递归算法的现实上限。
• BSS 不占可执行文件体积：编译器只需在文件里记一句「这里清零 N 字节」，不必把一整片 0 存进去。一个 int big[1000000]; 放 BSS 时文件几乎不变大，一旦给它加个非零初值就挪进 Data，文件立刻膨胀 4MB。

字段顺序真的会改变体积

• 两个字段完全相同、只是顺序不同的结构体：struct {char; int; char;} 的 sizeof 是 12，而 struct {int; char; char;} 只有 8——省了三分之一。前者两个 char 被 int 隔开，各自后面都得补齐。
• 规则可以概括成两条：每个字段要对齐到自身大小的倍数；结构体总大小要是其中最大对齐的整数倍(所以末尾也可能补齐)。据此，把大类型排前面、小类型聚在一起就能自然省下填充。
• 查真实偏移用 offsetof(<stddef.h>)，别自己数。C11 的 alignas/alignof(<stdalign.h>)可以显式指定或查询对齐。

预处理指令与宏

多文件与链接

Make 与 CMake

C99 / C11 / C23 特性矩阵

套路：列表接受一个 X，反复喂不同的 X

• 把列表定义成一个「接受 X 的宏」：#define COLORS(X) X(RED) X(GREEN) X(BLUE)；
• 每次拿不同的生成器宏当 X 展开它：一次生成 enum、一次生成字符串数组；
• 加新颜色只改 COLORS 那一行，enum 和字符串表自动同步。

典型用场

• 枚举 ↔ 字符串互转（日志、调试打印、协议字段名）；
• 操作码 / 状态机表（opcode + handler + 名字 三列平行）；
• 配置字段、序列化（字段名 + 类型 + 偏移一次声明、多处生成）；
• 寄存器 / 命令表——嵌入式最爱。

编译单元：编译器的视野边界

• 一个 .c，加上它 #include 进来的全部内容，展开后合成一个编译单元（翻译单元）。编译器一次只处理一个，产出一个 .o。
• 然后链接器把这些 .o 拼起来：把「这里用了 foo」和「那里定义了 foo」对上号。
• 关键在于链接器只认符号的名字，不认类型。它不知道 foo 是函数还是变量、参数是什么、返回什么——名字对上就接。这就是下面几个坑的共同根源。

.h 放声明，.c 放定义

• 声明说「有这么个东西，长这样」——函数原型、extern int x;。定义真正产生实体——函数体、int x = 0;。
• 头文件里只能放声明。把定义写进 .h，一旦被两个 .c 都包含，就是链接期的重复定义：

  ld: multiple definition of `counter'; first defined here

• 文件作用域的 static 表示只在本编译单元可见——这是 C 的封装手段。别的 .c 想用就会撞上：

  ld: undefined reference to `hidden'

include guard：为什么每个头文件都要有

• 同一个 .c 里把一个头文件包含两次，往往不是手滑——而是间接的：a.h 和 b.h 都包含了 c.h，你只写了两行 include 就会遇到。
• 没有防护就是编译期错误：

  error: redefinition of `counter'
  note: previous definition of `counter' with type `int'

• 防护写法两种：老式的 #ifndef X_H / #define X_H / #endif（标准、到处能用），或 #pragma once（一行搞定，编译器几乎都支持但非标准）。
• 注意这两种「重复」炸在不同阶段：同一个编译单元里重复 → 编译期；两个编译单元各定义一次 → 链接期。这正好是 01 章「编译期 / 链接期 / 运行期」分诊法的实战用例。

链接顺序是有讲究的

• 库要放在用它的文件后面。链接器从左到右扫，遇到库时只挑「目前还缺的符号」。放反了就等于还没人要它的时候就扫过去了：

  gcc usr.o -L. -ltri     -> 成功
  gcc -L. -ltri usr.o     -> undefined reference to `triple'

• -lm（数学库）至今仍然必需，尽管 glibc 2.34 起 libpthread 已并入 libc（-pthread 不加也能链接了），libm 没有跟着并。
• 这里有个容易骗过自测的地方：写 sqrt(2.0) 这种常量实参，编译器会在编译期直接算出结果，二进制里根本没有 sqrt 这个符号，于是不加 -lm 也能链接成功——换成运行期才知道的值，立刻就 undefined reference to `sqrt'。验证链接问题时别用常量做实参。

一条规则的解剖

目标(target)： 依赖(prerequisites)
<Tab>命令(recipe)

• 目标：通常是要生成的文件名(app、main.o)；也可以是伪目标(clean)——不产出同名文件、只是一组动作，须用 .PHONY 声明，否则一旦目录里真有个叫 clean 的文件，规则就永远「不过时」而不执行。
• 依赖：这个目标依赖哪些文件；任一依赖比目标新，就触发重建。
• 命令：必须以 Tab 缩进(不是空格)，在子 shell 里执行；默认会回显，前缀 @ 可静音。
• 直接敲 make 构建第一条规则的目标(习惯上叫 all)；make clean 则指定构建某个目标。

变量的四种赋值——最容易含糊的点

• = 递归展开：用到时才求值，右侧引用的变量取「最终值」，容易意外自我引用甚至死循环。
• := 立即展开：定义当下就求值，行为最可预测——默认优先用它。
• ?= 仅当未定义时赋值：给可被环境或命令行覆盖的默认值(CC ?= gcc，之后 make CC=clang 即可覆盖)。
• += 追加：往已有值后面接(CFLAGS += -g)。

自动变量与模式规则：消除重复的关键

• 规则命令里这些符号免去手写文件名：$@=目标名、$^=全部依赖(去重)、$<=第一个依赖、$?=比目标新的那些依赖、$*=模式规则里 % 匹配到的主干。
• %.o: %.c 是模式规则：一条规则批量描述「任何 .o 都由同名 .c 编出」，省得为每个文件各写一遍。
• $(wildcard *.c) 收集源文件，$(patsubst %.c,%.o,$(SRCS)) 把 .c 列表转成 .o 列表——目录里新增一个 .c，Makefile 完全不用改。

头文件依赖：make 最大的陷阱与根治

make 只比时间戳、不看内容：你改了 math.h，但规则里 main.o 只声明了依赖 main.c——make 看不出 main.o 过时，于是不重编，造成「明明改了却没生效」的诡异现象。手写头文件依赖既繁琐又极易漏。根治办法是让编译器自动生成：gcc -MMD -MP 编译时顺带产出 .d 文件(内含 main.o: main.c math.h 这样的依赖行)，再用 -include 引进来，依赖关系全自动、永不遗漏(见下方代码)。

两段式：配置 → 构建

• ① 配置(configure/generate)：cmake -B build -G Ninja 读 CMakeLists.txt、探测编译器与依赖，在 build/ 里生成对应工程。
• ② 构建：cmake --build build 调用底层工具(Ninja/make/MSBuild)真正编译——这一步平台无关，CI 脚本因此一套通吃。
• 所有中间产物都进 build/(out-of-source 构建)，不污染源码树，rm -rf build 即彻底清理。

一切皆 target：Modern CMake 的核心

现代 CMake 的心法是面向 target而非全局设置：给具体目标设属性，并用三个关键字控制属性是否传递给依赖它的其他 target。

• PRIVATE：只自己用(实现文件需要的私有头目录/宏)。
• INTERFACE：只给用户、自己不用(纯头文件库的典型)。
• PUBLIC = PRIVATE + INTERFACE：自己用、也传给用户(库的公开头目录)。

于是 target_link_libraries(app PRIVATE core) 一句，会把 core 的 PUBLIC/INTERFACE 头目录、编译选项、宏定义自动带给 app——依赖一处声明、处处生效。别再用 include_directories、link_libraries 这类污染全局的老命令。

引入第三方库的三条路

• find_package(fmt REQUIRED)：找系统已装的库(经 xxxConfig.cmake 或 Findxxx.cmake)，配合 vcpkg / Conan 包管理器最常用。
• add_subdirectory(third_party/lib)：把随源码一起放进来的子项目纳入构建(git submodule 常这么用)。
• FetchContent：配置阶段直接从 Git 拉取并构建依赖，无需预装——小项目「开箱即用」的现代做法。

构建类型、缓存变量与 Presets

• 用 -D 传缓存变量覆盖默认：-DCMAKE_BUILD_TYPE=Release 选优化档(Debug 带调试信息、Release 开 -O3 -DNDEBUG)。
• 缓存变量首次配置后存进 build/CMakeCache.txt，之后不必重复传；改错了要么删 build/ 重来，要么再 -D 覆盖。
• CMakePresets.json 把生成器、构建类型、编译选项固化成命名预设，cmake --preset debug 一键复现，团队与 CI 共享同一套——比在 README 里写「请这样配置」可靠得多。

三招

• 系统包管理器（apt / dnf / brew / pacman）：apt install libcurl4-openssl-dev 把头文件 + 库装到系统路径；最省事，但版本你说了不算、换发行版就变、不可复现；
• pkg-config：装好后用它吐编译 / 链接旗标，免得手写 -I/-l/-L；
• vendor / submodule：把依赖源码直接放进仓库（third_party/ 或 git submodule）一起编——版本完全可控、可复现，代价是仓库变大、要自己跟上游。

想要「真·包管理器」体验

• 用 vcpkg / Conan（见上面 CMake 卡）——它们也支持 C 库；或用 CMake FetchContent 配置期拉源码。这几条把 C++ 生态那套借给 C 用，是目前最接近 Cargo 的做法。

C11 带来的三样，以及 C17 为什么没有新东西

C11 的 _Generic 按表达式类型在编译期选分支，是实现类型安全泛型宏的关键——它让 <tgmath.h> 这类类型泛型接口得以用可移植的标准 C 写出来（tgmath.h 本身是更早的 C99 特性）。C11 还有 <threads.h> 线程、<stdatomic.h> 原子操作（都在本章后面几张卡展开）、_Static_assert 编译期断言。至于 C23 在语言层的现代化（constexpr、auto 推导、nullptr、_BitInt、#embed 等），本章后面专门展开。

编译期断言的三种写法，各自从哪一档开始能用（分档）

• C23 在这件事上做了两处改动：把 static_assert 提升为关键字（不必再 #include <assert.h>，也不再需要那个带下划线的丑名字），以及允许省略消息（省了就拿表达式本身当消息）；
• 上表每一格都可以用 tip 里那条方法自行确认——-std=cNN -pedantic-errors 分档试编。不加 -pedantic-errors 时 gcc 会宽容放行，边界根本看不出来；
• 写新代码直接用 static_assert（gcc 15 不加 -std 默认就是 C23）；要兼容老编译器时才退回 _Static_assert，或 #include <assert.h> 后用宏形式。

常量与类型：constexpr / auto / nullptr

• constexpr——有类型的编译期常量。比 #define 强在它是真正的具名对象、参与类型检查、不会裸文本替换；比 enum 强在可以是任意类型（double、指针都行，enum 只能是 int）。
• auto——从初始化器推导类型，写 auto n = SIZE * 2; 就不必重复写 int。
• nullptr——有自己类型（nullptr_t）的空指针常量，终结 NULL 到底展开成 0 还是 (void*)0 的历史歧义。

字面量与嵌入：0b / _BitInt / #embed / %b / unreachable

• 二进制字面量 0b1010 + 数字分隔符 '：0b1010'1100、1'000'000——' 只为断句可读，不改变数值；printf 的 %b 反过来把整数按二进制打出，与 0b 对称。
• _BitInt(N)——精确 N 位的整数类型，做硬件寄存器、协议位段、定点数时不必再靠手工掩码硬凑位宽。
• #embed "file"——把任意文件的字节当初始化列表直接嵌进源码，取代 xxd -i 生成 C 数组那套老把戏。
• unreachable()（<stddef.h>）——标注「这里到不了」，既是文档，也让优化器删掉死代码；但真走到了就是 UB，别拿它兜运行期分支。
• static_assert 成了关键字——不必再 #include <assert.h>，也不必写带下划线的 _Static_assert，消息还可以省略（省了就拿表达式本身当消息）。三种写法各从哪一档开始能用，见本章前面的分档表。

「两次返回」到底怎么读

• 调用后内核把当前进程整个复制一份，于是同一行 fork() 在父子两个进程里各返回一次:父进程拿到子进程 PID(>0)、子进程拿到 0、失败返回 -1。
• 所以「我是谁」只能靠返回值来分辨。if (pid == 0) 那一支只有子进程会走，else 只有父进程会走——两条路写在同一份源码里，却由两个进程分头执行。
• 此后两者各跑各的:变量、堆、文件描述符表都是各自一份，改自己的不影响对方。

写时复制：说是复制，其实没真复制

• 「复制整个地址空间」听着极慢，实际不是——内核用写时复制(COW):父子先共享同一份物理页并标记为只读，谁真的去写，才在那一刻单独复制那一页。
• 于是 fork 本身很便宜，代价被推迟到真正发生写入时。这也解释了为什么 fork 紧接着 exec(本章后面)几乎不浪费：刚「复制」的页还没被写过，就被新程序整个丢掉了。

exec：换脑，且一去不返

• exec 系列把当前进程的内存映像整个替换成新程序——代码段、数据、堆栈全换掉，但进程号不变、打开的文件描述符默认继承。正因为 fd 会被继承，shell 才能先重定向再 exec。
• 成功就永不返回(调用它的那行之后的代码已经被覆盖掉了)。所以 exec 后面紧跟的语句只有一种含义：exec 失败了。不写错误处理，失败时会直接往下淌进本不该执行的代码。

wait：退出码与僵尸

• 父进程用 wait/waitpid 阻塞等子进程结束，并取回退出状态。status 是打包过的，别直接当数字用——要靠宏拆：WIFEXITED 判断是否正常退出、WEXITSTATUS 取退出码，WIFSIGNALED/WTERMSIG 则对应「被信号打死」。
• 子进程退出后，内核会保留一条记录(退出码等)直到父进程来取——这段时间它就是僵尸进程:已经死了，但还占着一个进程表项。父进程不 wait,僵尸就一直堆着。

管道：一对 fd 组成的单向字节流

• pipe() 一次给出两个文件描述符：读端 fd[0]、写端 fd[1],数据只能从写端流向读端。配合 fork(子进程继承这两个 fd)与 dup2(把管道接到标准输入输出上),就实现了 shell 的 a | b。
• 它是字节流,没有消息边界——写三次不等于读三次，和 TCP 完全一样的性质，08 章会把这件事展开讲透。
• 用完必须各关各的无用端:子进程读就关掉写端，父进程写就关掉读端。这不是洁癖，下面 tip 里说的挂死就出在这。

信号：异步打断，不排队

• 常见的几个：SIGINT(Ctrl-C)、SIGTERM(kill 默认发的)、SIGCHLD(子进程状态变化)、SIGSEGV(段错误)、SIGPIPE(往没人读的管道里写)。用 signal 或 sigaction 注册处理函数。
• 信号会在任意时刻打断主流程去执行处理函数，执行完再跳回原处继续——它不是消息队列，同种信号连发多次可能只被处理一次,别拿它传递计数或数据。

共享什么，不共享什么

• pthread_create 开一条线程去跑指定函数，pthread_join 等它结束并回收(不 join 又不 detach,就是线程版的资源泄漏)。
• 同进程的线程共享全局变量、堆、文件描述符表,但各有独立的栈。所以传数据不用管道、不用序列化,指针递过去就行——这是线程比进程「便宜」的真正含义。
• 反过来说：没有任何东西替你挡着。两个线程同时读写同一个变量而不加保护,就是数据竞争,行为未定义。

互斥锁：把三步变回一步

• 进临界区前 lock、出来 unlock,保证同一时刻只有一个线程在动共享数据——「读→加→写」这三步中途就不会被人插进来。
• 关键是凡是碰这份数据的地方都要加同一把锁。有一处漏了，其余全加也白搭：竞争只需要两个参与者，其中一个不守规矩就够了。

条件变量：为什么不能只用锁

• 光有锁，「等队列非空」只能写成循环反复抢锁查看,即忙等——空转烧 CPU,还因为一直占着锁反而拖慢了那个本该来填数据的线程。
• pthread_cond_wait 做的是一件原子的事:放开锁 + 让线程睡下。睡着时不占 CPU、也不占锁，生产者才进得来；被 signal 唤醒后它会自动重新拿回锁再返回,所以醒来那一刻你依旧安全地处在临界区里。
• "锁 + 条件变量 + while 检查"这三件套就是生产者 / 消费者模型的标准配方,右边这段可以直接当模板抄。

原子类型：把三步交给硬件

• C11 的 <stdatomic.h> 提供原子类型:对 atomic_long 的自增由硬件指令保证不可分割，那个「读→加→写」的窗口从根上消失了，不需要锁。
• 右边这段和线程那张卡的代码只差一行，结果却精确等于 2000000,把丢掉的更新一分不差地补了回来。
• 适用范围也就到这了：计数器、标志位、单个指针的交换这类「一个变量、一步操作」。一旦临界区里要同时改两个变量并保持它们一致，原子就无能为力了——那是锁的活。

内存序：便宜背后的代价

• 多线程下「我这个线程的写，什么时候对别的线程可见」并不是理所当然的——编译器和 CPU 都会重排指令。memory_order 就是你对这件事提出的要求。
• 默认的 seq_cst 最强也最符合直觉(所有线程看到的操作顺序一致),代价是要插内存屏障。追求性能时可以退到 acquire / release,但那需要你能准确说清「哪个写必须在哪个读之前可见」。
• 背后的硬件原理(为什么会重排、缓存之间怎么同步)见计算机组成页的「内存一致性模型」与「MESI」两卡。

qsort / bsearch 的契约

字符串转数字

标准库的边界

选型表

• strcpy(dst, src)——不做任何长度检查。只有在你能证明目标装得下时才用（比如刚 malloc(strlen(src)+1)）。
• strncpy(dst, src, n)——名字看着是「安全版 strcpy」，但它根本不是为此设计的（见下），日常别用。
• snprintf(dst, n, "%s", src)——推荐的默认选择。永远补 \0，能截断，还能顺便拼接和格式化。返回值是「本该写入的长度」，比 n 大就说明被截断了——这是唯一可靠的截断检测方式（08 章写 HTTP 服务器时正栽在这上面）。
• memcpy(dst, src, n)——拷贝已知长度的字节，不管 \0。处理二进制数据用它，而且它通常最快。区域重叠要用 memmove。

两个和「长度」有关的常见错误

• sizeof 和 strlen 不是一回事：char s[16] = "abc"; 的 sizeof s 是 16（缓冲区大小），strlen(s) 是 3（内容长度）。而一旦数组作为参数传进函数就退化成指针，sizeof 只剩指针大小——02 章「数组与字符串」讲过这个退化。
• 循环 strcat 是 O(n²)：strcat 每次都要从头扫到结尾才知道往哪儿接。在循环里拼 n 段，总代价是 n² 级的。正确做法是自己维护一个「当前写到哪」的指针或偏移，或者用 snprintf 的返回值往前推进。这不是微优化——拼几万段时是秒级和分钟级的差别。

比较：别写 == -1

• strcmp 的契约只保证符号：小于返负、等于返 0、大于返正。不保证是 -1／0／1。
• glibc 上strcmp("a","c")、strcmp("a","z")、strcmp("apple","banana") 全都返回 -1，但这只是这个实现碰巧如此——换个平台可能返回字符差值。写 if (strcmp(a,b) == -1) 的代码能在你的机器上通过全部测试，然后在别人的机器上悄悄失效。一律写 < 0 / == 0 / > 0。

标准库返回的指针只有三类

• ① 调用方负责 free：malloc／calloc／realloc，以及 strdup（POSIX）。拿到就欠了一笔债，忘了还就是泄漏。
• ② 指向你自己传进去的缓冲区内部：strchr／strstr／strtok／memchr 返回的是入参内部的某个位置。不用释放，但它的寿命跟着原缓冲区——原缓冲区被 free 或出了作用域，这个指针立刻悬空。
• ③ 指向库内部的静态缓冲：strerror／localtime／gmtime／asctime／ctime／getenv。不能释放，而且下一次调用同一个函数就会把内容冲掉。这一类最危险，因为出错时数据是「变了」而不是「没了」。

strtok：既改你的入参，又有隐藏状态

• 它就地改写原字符串：把每个分隔符替换成 \0。"a,b,c" 切完之后，原缓冲区变成 97 0 98 0 99 0——原串被破坏了，再想用完整的它已经来不及。所以不能拿它切字符串字面量（那是只读内存，会段错误），要先拷一份。
• 它还把「切到哪了」存在库内部的静态变量里，所以第二次起传 NULL。后果是：不能同时切两个字符串（会互相打断），多线程里用它是灾难，被调用的函数里如果也用了 strtok，你的循环会莫名其妙地乱掉。
• 替代：POSIX 的 strtok_r（把状态交给你自己保存），或者干脆用 strchr 自己走一遍——通常也就多五行。

怎么把约定写进自己的代码

• C 表达不了所有权，所以只能靠命名和文档：返回需要释放的内存时，函数名里带上 _new／_dup／_create，并在头文件的声明上方一行写明「调用方负责 free」。
• 更省事的办法是反过来设计：让调用方传缓冲区进来（像 snprintf、localtime_r 那样），函数只负责填。这样根本没有所有权转移，也就没有泄漏——标准库后来补的可重入版本，走的都是这条路。

契约的其余部分

• 参数是 const void *，指向的是元素本身。比较 char * 数组时，参数是指向指针的指针——要写 *(const char **)a，少一层解引用是这里的经典错误。
• 必须是一致的全序：cmp(a,b) 和 cmp(b,a) 符号相反、相等有传递性。比较函数如果自相矛盾（比如里面用了随机数或浮点 NaN），qsort 的行为是未定义的——不只是结果乱，是可能越界访问。
• 浮点要小心 NaN：任何和 NaN 的比较都返回假，于是 (x>y)-(x<y) 对 NaN 恒为 0，破坏传递性。数据里可能有 NaN 就得先单独处理。
• qsort 不保证稳定——相等元素的原有相对次序标准不作要求。glibc 的实现在某些规模下碰巧是稳定的，这恰恰是危险所在：依赖稳定性的代码能在你的机器上通过测试，换个数据规模或换个平台就出错。要稳定就把原始下标作为最后一个比较字段放进比较函数里。

strtol：三个判据缺一不可

strtol 能报告一切，代价是你要检查三件事：

• ① 一个数字都没解析出来：end == 输入。这时返回 0，但没解析成功。
• ② 溢出：errno == ERANGE，返回值是 LONG_MAX／LONG_MIN。因为返回值本身是合法数值，只能靠 errno 判断——所以调用前必须 errno = 0（原因见 07 章 errno 卡）。
• ③ 后面还有尾巴：*end != '\0'，比如 "12abc" 会解析出 12 然后停在 a。要不要接受取决于你的场景，但必须是有意识的决定，不能默认忽略。
• 还有个细节：第三个参数是进制，传 0 表示「自动识别」——0x 开头按十六进制、0 开头按八进制。所以用户输入 "010" 会变成 8。要十进制就明确写 10。

sscanf：方便，但错误信息很粗

• sscanf(s, "%d", &v) 返回成功赋值的项数，所以至少能判断「成没成」——比 atoi 强。
• 但它区分不了溢出（行为未定义），也不告诉你停在哪里，尾部有垃圾时默认接受。适合解析你自己控制的格式，不适合校验外部输入。
• 02 章「健壮读入」讲的 fgets + strtol 组合之所以是推荐姿势，原因就在这里：读入和解析分开，各自都能报错。

rand：够用在哪，不够用在哪

• 绝对不能用于任何安全用途——密钥、令牌、密码、会话 ID。它是可预测的伪随机数，知道种子就能算出整个序列。安全场景在 Linux 上用 getrandom() 或读 /dev/urandom。
• rand() % n 有取模偏差：如果 RAND_MAX + 1 不能被 n 整除，小余数出现的概率会略高。不过要说清楚量级——glibc 上 RAND_MAX 是 2147483647，取模到个位数时偏差约为七亿分之一，实跑三百万次根本测不出来。所以对游戏掷骰子这类用途，% n 完全够用；只有当 n 大到和 RAND_MAX 一个量级时，偏差才会变得实际。
• 真正该注意的反而是：rand 的随机性质量不由标准保证，不同实现差别很大；不调 srand 时序列每次运行都一样（这在调试时是优点，发布时是 bug）；而 srand(time(NULL)) 在一秒内启动多次会拿到同一个种子。

宽字符与 locale：现代程序基本不该碰

• wchar_t 的宽度由实现决定——Linux 上通常 4 字节，Windows 上 2 字节。它不是一个可移植的 Unicode 方案，用它写跨平台代码只会痛苦。
• 今天的标准答案是：内部一律用 UTF-8 存在普通的 char 数组里，只在真正需要按字符（而非字节）操作时才解码。大部分程序——拼接、比较、传输、存储——根本不需要解码，UTF-8 的设计就是为了让字节操作依然安全。
• setlocale 会全局地改变 printf 的小数点、strcoll 的排序规则、isalpha 的判定。在库代码里调它是在给调用方埋雷。要调就只在 main 里调一次，而且明确指定要改哪一类（如只改 LC_TIME）。

signal：ISO C 的那份太弱

• ISO C 的 signal() 只保证极少的东西，信号处理函数里能合法做的事少得惊人：只能读写 volatile sig_atomic_t 类型的变量、调用 _Exit 之类的少数函数。printf、malloc、free 在信号处理函数里都是不安全的——它们可能正被主流程执行到一半。
• 标准的处理模式是：处理函数里只设一个标志位，真正的活儿回到主循环里做。
• 要认真处理信号就用 POSIX 的 sigaction（07 章 POSIX 那章有），它能精确控制重启语义和屏蔽字；signal() 的行为在不同系统上甚至不一致。

setjmp/longjmp：看着像异常，其实不是

• 它能跨函数跳转，常被拿来模拟异常。但它不做任何清理——跳过去的路上，那些已经 malloc 的内存、已经 open 的文件、已经加上的锁，全都不会被释放。
• 而且跳转后，非 volatile 的局部变量的值是未定义的。
• 结论：除非在写解释器、协程这类确实需要非局部跳转的东西，老老实实用返回值传错误，配合 03 章那个 goto cleanup 的单出口清理链。

按任务找