简介

C 基础入门 (Basic C Tutorial)

📖 学习内容概览

欢迎来到 C 编程之旅的第一站！基础入门部分将带你掌握 C 语言的核心概念和编程范式。这些知识是后续所有高级主题（内存管理、并发编程、系统编程）的基石。

C 语言诞生于 1972 年，是世界上最古老但仍广泛使用的编程语言之一。我发现，学习 C 语言就像学习武术的基本功——虽然初期枯燥，但一旦掌握，学习任何其他语言都会事半功倍。

🎯 你将学到什么

完成本部分学习后，你将能够：

1. 理解 C 语言的变量与数据类型系统 - 静态类型的力量与约束
2. 掌握指针与内存地址 - C 语言最核心、最独特的概念
3. 使用结构体和枚举 - 组织复杂数据
4. 理解手动内存管理 - malloc / free 的责任与自由
5. 编写函数指针与回调 - 实现 C 语言的多态
6. 进行文件 I/O 操作 - 持久化你的程序数据
7. 使用调试与日志工具 - 高效排查程序问题

📚 章节列表

US1：基础概念 (Basic Concepts) — 入门阶段 🟢

US2：中级概念 (Intermediate Concepts) — 进阶阶段 🟡

US3：高级概念 (Advanced Concepts) — 熟练阶段 🔴/🟡/🟢

📈 学习路径图

                        ┌─────────────────────┐
                        │   US1: 基础概念 🟢   │
                        │   (8 章, ~3.5 小时)  │
                        └─────────┬───────────┘
                                  │
          ┌───────────────────────┼───────────────────────┐
          │                       │                       │
    变量与表达式            数据类型 + 运算符          函数 + 数组
          │                       │                       │
          └───────────┬───────────┘                       │
                      │                                   │
              控制流 + 循环 + 预处理器 ◄───────────────────┘
                      │
                      ↓
                        ┌─────────────────────┐
                        │   US2: 中级概念 🟡   │
                        │   (7 章, ~4.5 小时)  │
                        └─────────┬───────────┘
                                  │
          ┌───────────────────────┼───────────────────────┐
          │                       │                       │
       指针 ◄── 指针运算      字符串 + 结构体        枚举 + 作用域
     (最难点)
          │
          ↓
                        ┌─────────────────────┐
                        │   US3: 高级概念 🔴   │
                        │  (12 章, ~6.5 小时)  │
                        └─────────┬───────────┘
                                  │
          ┌───────────────────────┼───────────────────────────────┐
          │                       │                               │
     内存管理               函数指针 + 回调              文件 I/O + 头文件
   (最重要)             (C 的多态)
          │                       │                               │
          └───────────┬───────────┘                               │
                      │                                           │
          void* + 位运算 + CLI + stdlib ◄─────────────────────────┘
          (系统编程基础)
                      │
                      ↓
                  🎓 毕业 → 高级进阶

依赖关系说明：

• 🔵 US1 → US2：理解指针前必须先掌握变量和数组
• 🔵 US2 → US3：理解内存管理前必须先掌握指针运算
• 🔵 指针 → 函数指针：函数指针是指针概念的延伸
• 🔵 结构体 + 函数指针 → 回调：回调需要这两者的组合

我的建议是 按顺序学习，不要跳级。C 语言的知识体系像搭积木，底层概念不牢固，高层概念就会崩塌。

✅ 学习清单

完成本部分后，你应该能够对自己说出以下每一句话：

US1 基础概念:

• "我能声明各种类型的变量并正确初始化它们"
• "我知道 int、float、double、char 的区别和各自的大小"
• "我能编写简单的函数，理解参数是按值传递的"
• "我能正确使用算术、关系、逻辑运算符"
• "我知道数组在内存中是连续存储的"
• "我能用 if/else、switch、for、while 控制程序流程"
• "我理解预处理器的作用，知道 #include 和 #define 在做什么"

US2 中级概念:

• "我能解释什么是指针——它就是一个存储内存地址的变量"
• "我能区分「指针本身」和「指针指向的内容」"
• "我能进行基本的指针运算，理解数组下标 a[i] 本质上是 *(a+i)"
• "我知道 C 字符串就是 \0 结尾字符数组"
• "我能定义和使用结构体来组织相关数据"
• "我知道枚举是定义一组命名常量的方式"
• "我能解释变量的作用域和生命周期"

US3 高级概念:

• "我能使用 malloc/free 进行动态内存分配，并保证每次 malloc 都有对应的 free"
• "我能声明和调用函数指针"
• "我能使用回调函数实现可复用的算法（如 qsort）"
• "我能打开、读取、写入、关闭文件"
• "我能组织多文件项目，编写头文件守卫"
• "我能使用 printf 的完整格式化能力"
• "我至少用过一种调试方法（gdb 或 assert）"
• "我能理解条件编译在多平台开发中的作用"
• "我知道 void* 可以用来实现泛型代码"
• "我能进行基本的位运算（AND/OR/XOR/SHIFT）"
• "我能解析命令行参数"
• "我知道 C 标准库提供了哪些常用工具函数"

🎓 实践项目

建议练习（按学习阶段）：

1. 🟢 初学者项目：学生成绩管理系统（变量、数组、函数、控制流）
2. 🟢 初学者项目：简易计算器（运算符、函数、控制流）
3. 🟡 中级项目：通讯录程序（结构体、字符串、文件 I/O）
4. 🟡 中级项目：扑克牌洗牌与发牌（指针、数组、随机数）
5. 🔴 高级项目：简易内存池（动态内存管理、指针运算）
6. 🔴 高级项目：事件调度器（函数指针、回调、链表）

➡️ 下一步

完成基础入门后，你可以选择以下学习路径：

• 高级进阶 — 深入学习 C 的高级特性：

  • 数据结构（链表、树、哈希表）
  • 网络编程（Socket、TCP/UDP）
  • 多线程编程（POSIX Threads）
  • 跨平台开发

• 算法练习 — 用 C 实现经典算法：

  • 排序与搜索算法
  • 图算法
  • 动态规划

准备好了吗？让我们开始 变量与表达式 的学习！ 🚀

📊 统计总览

📈 学习路径

变量与表达式 → 数据类型 → 函数 → 运算符 → 数组 → 控制流 → 循环
→ 预处理器 → 指针 → 指针运算 → 字符串 → 结构体 → 结构体字段
→ 枚举 → 作用域 → 内存管理 → 函数指针 → 回调函数 → 文件 I/O
→ 头文件 → 日志 → 调试 → 条件编译 → void* 泛型 → 位运算
→ 命令行参数 → 标准库 → 🎓 毕业

📚 延伸阅读

完成基础入门后，你可能还想了解：

• Kernighan & Ritchie《The C Programming Language》 — C 语言圣经（K&R）
• C17 标准（ISO/IEC 9899:2018） — C 语言的官方标准
• cppreference - C 语言 — 权威在线参考

选择建议：

• 想开始学习 → 继续学习 变量与表达式
• 想快速上手 → 先看完 学习路径图 再开始

变量与表达式

开篇故事

想象你走进一家酒店。前台接待员不会随便把客人塞进任何房间——她会先看客人是一个人还是带家属，然后安排对应的房型。单人房放单人床，家庭房放两张大床，套房配客厅和书房。如果硬把一套家具塞进单人房，要么放不下，要么把房间撑坏。

C 语言的变量就像这些房间。声明变量时，你告诉编译器「这个格子存什么类型的数据」。int 房间只能住整数，double 房间只能住浮点数。C 要求你在放东西之前先指定房型，不像 Python 或 JavaScript 那样可以随意更换内容。这种「提前声明」看似约束，其实是在编译阶段就帮你排除了大量错误——就像酒店提前分配好房间，入住时不会手忙脚乱。

变量是程序的记忆单元，表达式是程序的计算肌肉。二者结合，就是 C 语言最基础的能力。

本章适合谁

本章面向完全没有 C 语言经验的初学者。如果你用过 Python、JavaScript、Java 等高级语言，本章会帮助你理解 C 的变量系统与它们的差异。如果你是完全零基础的新手，也没关系——我会从最基础的概念讲起，每一步都有可运行的代码示例。

你会学到什么

1. 如何声明和初始化不同类型的变量（int、double、char、int64_t）
2. const 关键字的作用，以及它与 #define 宏的区别
3. 算术运算符的使用：+、-、*、/、%，以及整数除法与浮点除法的陷阱
4. 变量的作用域规则，包括块级作用域和变量遮蔽（shadowing）
5. 前缀自增（++x）与后缀自增（x++）的实际差异

前置要求

无需前置。这是 C 基础教程的第一章，我们从零开始。只需确保你的系统安装了 GCC 编译器（gcc --version 能输出版本号即可）。

第一个例子

下面是一段最简短的 C 变量演示。它声明了三个变量，打印它们的值，并做一次加法运算：

#include <stdio.h>

int main(void) {
    int a = 10;       /* 声明并初始化整型变量 a */
    double b = 3.5;   /* 声明并初始化双精度浮点数 b */
    int sum = a + 5;  /* 表达式：a + 5 的结果赋值给 sum */

    printf("a = %d\n", a);
    printf("b = %.1f\n", b);
    printf("sum = a + 5 = %d\n", sum);

    return 0;
}

编译并运行：

gcc -Wall -Wextra -std=c17 -o demo demo.c
./demo

输出：

a = 10
b = 3.5
sum = a + 5 = 15

这段代码做了三件事：

• 声明变量：告诉编译器 a 是整数、b 是浮点数
• 初始化：在声明的同时赋予初始值
• 表达式求值：a + 5 是一个表达式，编译器先计算再赋值

原理解析

变量声明与初始化

在 C 语言中，声明变量需要指定类型和名称：

int age;         /* 仅声明，未初始化（值不确定） */
int count = 0;   /* 声明并初始化 */

我强烈建议始终在声明时初始化。未初始化的局部变量包含的是内存中的随机值，使用它会导致不可预测的行为。

C 语言提供了多种整数和浮点类型，各有不同的取值范围：

int8_t、int64_t 等类型定义在 <stdint.h> 中，它们保证了跨平台的精确宽度——这比直接用 int、long 更可靠。

const 常量

const double PI = 3.14159265;
const int MAX_USERS = 100;

const 告诉编译器这个变量的值不能被修改。如果你尝试：

const int MAX = 10;
MAX = 20;  /* ❌ 编译错误：只读变量 */

编译器会直接报错：

error: assignment of read-only variable 'MAX'

const vs #define

#define BUFFER_SIZE 256       /* 预处理宏：编译前直接文本替换 */
const int MAX_NAME = 64;      /* const 变量：编译器知道它的类型 */

我的建议是：优先使用 const。它有类型安全检查，调试时能直接看到值。#define 只适合条件编译（如 #ifdef __linux__）或真正的编译时常量。

作用域基础

变量的作用域（Scope）决定了它在哪些地方可见：

int global = 100;  /* 全局变量：整个文件可见 */

void func(void) {
    int local = 50;  /* 局部变量：仅在 func 内可见 */
    {
        int block = 20;  /* 块级变量：仅在这个 { } 内可见 */
    }
    /* block 在这里已经不存在了 */
}

变量遮蔽（Shadowing）：内层可以声明与外层同名的变量，但这只是「同名不同柜」：

int x = 1;
{
    int x = 999;  /* 遮蔽了外层的 x */
    /* 这里的 x 是 999 */
}
/* 这里的 x 还是 1 */

算术运算符

C 语言提供了五种基本算术运算符：

整数除法是最常见的陷阱之一。当两个整数相除时，结果会被截断（不是四舍五入）：

int result = 7 / 2;          /* result = 3, 不是 3.5 */
double precise = 7.0 / 2;    /* precise = 3.5 */
double cast = (double)7 / 2; /* cast = 3.5，通过强制转换 */

要获得精确的浮点除法，只需操作数中至少一个是浮点数。

常见错误

错误 1：使用未初始化的变量

/* ❌ 错误代码 */
int x;
printf("x = %d\n", x);  /* x 的值是随机的！ */

编译器警告（-Wextra 会提示，但不一定报错）：

warning: 'x' is used uninitialized [-Wuninitialized]

/* ✅ 修复 */
int x = 0;  /* 始终初始化 */
printf("x = %d\n", x);

错误 2：整数除法误当作浮点除法

/* ❌ 错误代码 */
double avg = 7 / 2;
printf("avg = %.1f\n", avg);  /* 输出 3.0，不是 3.5 */

问题：7 / 2 是两个 int 相除，结果是 int 类型的 3，再转换为 double 变成 3.0。

/* ✅ 修复：让任一操作数为浮点数 */
double avg = 7.0 / 2;      /* 方法1：字面量加 .0 */
double avg2 = (double)7 / 2; /* 方法2：强制类型转换 */

错误 3：溢出——超出变量范围

/* ❌ 错误代码 */
#include <stdint.h>
int32_t max = 2147483647;
int32_t next = max + 1;  /* 溢出！回绕到 -2147483648 */
printf("%d\n", next);    /* 输出: -2147483648 */

/* ✅ 修复：使用更大类型 */
#include <stdint.h>
int64_t max = 2147483647LL;
int64_t next = max + 1;  /* 安全 */
printf("%lld\n", (long long)next);  /* 输出: 2147483648 */

动手练习

🟢 入门：交换两个变量

写一段代码，交换 int a = 5 和 int b = 10 的值。提示：使用一个临时变量 temp。

int a = 5, b = 10;
printf("交换前: a = %d, b = %d\n", a, b);

int temp = a;
a = b;
b = temp;

printf("交换后: a = %d, b = %d\n", a, b);
/* 输出: a = 10, b = 5 */

🟡 中级：摄氏度转华氏度

公式：F = C × 9/5 + 32。注意 9/5 在 C 中是整数除法！写一段代码，将 25.0 摄氏度转换为华氏度。

double celsius = 25.0;
double fahrenheit = celsius * 9.0 / 5.0 + 32.0;
printf("%.1f°C = %.1f°F\n", celsius, fahrenheit);
/* 输出: 25.0°C = 77.0°F */

🔴 挑战：不用临时变量交换两个整数

你能不使用第三个变量，仅通过算术运算交换 a 和 b 吗？提示：用加法和减法。

int a = 5, b = 10;
printf("交换前: a = %d, b = %d\n", a, b);

a = a + b;  /* a = 15 */
b = a - b;  /* b = 15 - 10 = 5 */
a = a - b;  /* a = 15 - 5 = 10 */

printf("交换后: a = %d, b = %d\n", a, b);
/* 输出: a = 10, b = 5 */

故障排查 (FAQ)

Q：为什么 C 语言要求声明变量类型，而 Python 不需要？

A：C 是静态类型（Static Typing）语言，编译器在编译期就需要知道每个变量的内存布局。Python 是动态类型，类型检查推迟到运行时。静态类型的好处是：编译期就能发现类型错误，运行时更高效。

Q：int 到底是多大？4 字节？

A：C 标准只保证 int 至少 16 位。在现代桌面系统（macOS、Linux、Windows）上，int 通常是 32 位（4 字节）。如果需要精确宽度，请使用 <stdint.h> 中的 int32_t。

Q：% 运算符能用于浮点数吗？

A：不能。% 只适用于整数。如果需要浮点数取余，请使用 <math.h> 中的 fmod() 函数。

Q：++i 和 i++ 到底有什么区别？

A：两者都会让 i 加 1，但返回值不同：

• ++i（前缀）：先加，返回新值
• i++（后缀）：先返回旧值，再加

当单独一行使用时效果相同。区别在于 j = ++i 和 j = i++ 时。

知识扩展 (选学)

整数的二进制表示

计算机内部用二进制（0 和 1）存储整数。以 8 位有符号整数（int8_t）为例：

最高位是符号位（0 = 正，1 = 负）。这也是 int8_t 范围是 -128 ~ 127 的原因：2⁸ = 256 种状态，一半给正数（含 0），一半给负数。

复合赋值运算符

你可以用复合赋值运算符简化代码：

x += 5;   /* 等价于 x = x + 5 */
x -= 3;   /* 等价于 x = x - 3 */
x *= 2;   /* 等价于 x = x * 2 */
x /= 4;   /* 等价于 x = x / 4 */
x %= 7;   /* 等价于 x = x % 7 */

这些运算符不仅简洁，而且在某些情况下编译器能生成更高效的机器码。

小结

本章我们学习了 C 语言变量的核心概念：

• 变量声明：类型 名称 = 值; — 始终初始化你的变量
• 数据类型：int、double、char、int64_t 等，用 <stdint.h> 获得精确宽度
• const 常量：比 #define 更安全，有类型检查
• 算术运算：+、-、*、/、%，注意整数除法会截断
• 作用域：变量只在声明它的 {} 块内可见，内层可以遮蔽外层
• 类型转换：(double)7 / 2 获得浮点除法

核心术语：

• Variable / 变量
• Data Type / 数据类型
• Declaration / 声明
• Initialization / 初始化
• Scope / 作用域
• Const Correctness / 常量正确性
• Integer Division / 整数除法
• Type Casting / 类型转换
• Shadowing / 遮蔽

术语表

延伸阅读

• C17 标准（ISO/IEC 9899:2018） — C 语言的官方标准
• cppreference - C 语言 — 权威在线参考
• Kernighan & Ritchie《The C Programming Language》 — C 语言的经典教材

选择建议：初学者推荐先阅读cppreference 的相关章节加深理解；有一定基础后可以直接参考 C17 标准原文。

继续学习

本章你已经掌握了 C 语言最基本的变量和表达式。下一步，我们将学习 C 语言丰富的数据类型——包括结构体、枚举和联合体。

• 上一章：回到课程主页
• 下一章：数据类型

数据类型 (Data Types)

开篇故事

想象你面前有一盒画笔，有粗毛笔、细勾线笔、橡皮和尺子。你不会用毛笔写字，也不会用尺子画画——每种工具都有自己最适合的工作。选错了工具，不仅效率低，还可能搞砸整幅画。

C 语言的数据类型就是这样的工具箱。int 是整数专用的勾线笔，double 是处理小数的细毛笔，char 是处理单个字符的橡皮。每种类型规定了数据占多少字节、能表示多大的范围、能存多精确。int8_t 只占 1 字节，适合存开关状态；int64_t 有 8 字节，能装下几十亿的大数。如果你用 int8_t 去存 256，就像拿橡皮去刻石头——不是不行，是根本不对路。

在 C 语言中，选择正确的数据类型是理解计算机如何管理内存的第一步。每种类型都有确定的字节数、范围和精度。掌握了这些，你就掌握了 C 语言的核心。

工具选对了，画画就顺手了。——民间谚语

本章适合谁

• 刚学完"变量与表达式"，想知道 C 语言有哪些数据类型
• 对 int、float、char 只停留在表面认识，想深入理解它们的区别
• 听说过 int32_t、uint64_t 但不知道为什么需要它们
• 想知道 sizeof 运算符和类型修饰符 const 的用法
• 希望理解不同平台上类型大小可能不同的问题

你会学到什么

• int8_t / int16_t / int32_t / int64_t ——精确宽度的整数类型
• float 和 double ——浮点数的精度差异
• char、signed char、unsigned char ——字符和单字节整数
• sizeof 运算符 ——查询类型或变量的字节大小
• INT_MAX / FLT_MAX 等极限常量 ——了解每种类型的取值范围
• signed / unsigned 修饰符 ——正负范围的切换
• const 类型修饰符 ——定义只读常量

前置要求

• 已完成 变量与表达式 章节
• 已配置 C 编译环境（gcc 或 clang）
• 了解基本的 printf 用法

💡 小知识：本教程代码符合 C17 标准（-std=c17），使用 <stdint.h> 中的精确宽度类型。

第一个例子

这是本章最简短的例子——看看 sizeof 能告诉你什么：

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

int main(void) {
    printf("char    = %zu 字节\n", sizeof(char));
    printf("int     = %zu 字节\n", sizeof(int));
    printf("int64_t = %zu 字节\n", sizeof(int64_t));
    printf("float   = %zu 字节\n", sizeof(float));
    printf("double  = %zu 字节\n", sizeof(double));
    return 0;
}

完整源码在仓库 src/basic/datatype.c。

原理解析

1. 整数类型：从 int 到 int64_t

C 语言提供多种整数类型。传统的 int、short、long 在不同平台上的大小可能不同——这在 cross-platform 编程中是个大坑。

从 C99 开始，<stdint.h> 提供了一组精确宽度类型，保证在所有平台上大小一致：

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

int main(void) {
    int8_t  status   = -1;
    int32_t count    = 42;
    int64_t filesize = 9223372036854775807LL;

    // 使用 PRId8、PRId32、PRId64 格式化宏（来自 <inttypes.h>）
    printf("status:   %" PRId8 "\n", status);
    printf("count:    %" PRId32 "\n", count);
    printf("filesize: %" PRId64 "\n", filesize);
    return 0;
}

💡 小知识：PRId8 是一个格式化宏，在不同平台上会被展开为 "d" 或其他合适的格式。它确保 printf 能正确读取 int8_t 类型。

2. 浮点类型：float vs double

浮点数用于表示小数。C 语言提供两种基本浮点类型：

float  pi_float  = 3.14159f;       // 4 字节，单精度
double pi_double = 3.14159265358979; // 8 字节，双精度

• float：大约 7 位有效数字
• double：大约 15 位有效数字

我的经验：除非在嵌入式系统中内存非常紧张，否则我默认使用 double。精度不足的代价可能远超节省的 4 字节。

3. 字符类型：不只是字符

char 在 C 语言中是一个字节，但它既可以是字符，也可以是小整数：

char        c  = 'A';      // 字符，ASCII 值 65
signed char   sc = -42;     // 有符号，范围 -128 ~ 127
unsigned char uc = 200;     // 无符号，范围 0 ~ 255

重要：char 到底是有符号还是无符号，取决于编译器。如果你需要明确的符号行为，请始终使用 signed char 或 unsigned char。

4. sizeof 运算符

sizeof 是 C 语言的内置运算符（不是函数！），返回类型或变量的字节数。

#include <stdio.h>

int main(void) {
    int x = 42;
    printf("int 类型大小: %zu 字节\n", sizeof(int));   // 类型
    printf("变量 x 大小:  %zu 字节\n", sizeof(x));      // 变量
    printf("表达式大小:   %zu 字节\n", sizeof(x + 1));   // 表达式
    return 0;
}

🧪 动手试试：试试 sizeof(double) 和 sizeof(double) 是否相等。试试 sizeof(3.14) 的结果是多少？（提示：3.14 默认是 double 类型）

5. 类型极限（Limits）

C 标准库在 <limits.h> 和 <float.h> 中定义了每种类型的最大值和最小值：

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
    printf("INT_MAX  = %d\n", INT_MAX);     // 2147483647
    printf("INT_MIN  = %+d\n", INT_MIN);    // -2147483648
    printf("UINT_MAX = %u\n", UINT_MAX);    // 4294967295
    printf("FLT_MAX  = %.2e\n", FLT_MAX);   // 3.40e+38
    printf("DBL_MAX  = %.2e\n", DBL_MAX);   // 1.79e+308
    printf("CHAR_BIT = %d\n", CHAR_BIT);    // 8（一个 char 有多少位）
    return 0;
}

我的建议：在写数值相关的代码时，养成查极限常量的习惯。它可以帮你避免溢出错误。

6. signed 与 unsigned

类型前面的 signed 和 unsigned 修饰符决定了该类型能否表示负数。

signed int   si = -10;   // 可以表示负数
unsigned int ui = 10;    // 只能表示 0 及正数

// unsigned 的范围更大（正数多一倍）
// signed int:   -2147483648 ~ 2147483647
// unsigned int: 0           ~ 4294967295

⚠️ 危险：将 signed 和 unsigned 混用进行算术运算或比较时，C 会自动将 signed 转为 unsigned。-1 会变成一个巨大的正数！

#include <stdio.h>

int main(void) {
    signed int   a = -1;
    unsigned int b = 2;
    if (a > b) {
        printf("-1 > 2 ？？\n");  // 会打印！因为 -1 转为 unsigned 后是一个巨大的数
    }
    return 0;
}

7. const 类型修饰符

const 告诉编译器：这个变量的值在初始化后不应该被修改。

const int   MAX_RETRIES = 3;
const float GRAVITY     = 9.81f;
const char *GREETING    = "Hello, C!";

我的理解：const 不仅仅是编译时的安全检查——它也向阅读代码的人传达意图。看到 const，我就知道"这个值不应该被改变"。

常见错误

❌ 错误 1：赋值超出类型范围

#include <stdint.h>

int8_t temperature = 200;  // ❌ int8_t 最大值是 127！

编译器警告（使用 -Wall -Wextra）：

warning: implicit conversion from 'int' to 'int8_t' changes value from 200 to -56

✅ 修复：使用更大类型

int16_t temperature = 200;  // ✅ int16_t 范围 -32768 ~ 32767

❌ 错误 2：修改 const 变量

const int MAX = 100;
MAX = 200;  // ❌ error: assignment of read-only variable 'MAX'

✅ 修复：如果值需要改变，去掉 const

int max = 100;  // ✅ 可以修改
max = 200;

❌ 错误 3：signed/unsigned 比较陷阱

#include <stdio.h>

int main(void) {
    int array_length = -1;      // -1
    unsigned int size = 5;      // 5
    if (array_length < size) {  // ❌ -1 被当作 unsigned，变成一个很大的数
        printf("-1 < 5\n");     // 这行不会执行！
    }
    return 0;
}

✅ 修复：确保比较的两个变量类型一致

int array_length = -1;
int size = 5;
if (array_length < size) {      // ✅ 都是 signed int
    printf("-1 < 5\n");
}

动手练习

🟢 练习 1：sizeof 计算器

编写一段代码，依次打印 char、short、int、long、long long、float、double、long double 的字节大小，并找出哪个是当前平台上最大的基本类型。

#include <stdio.h>

int main(void) {
    printf("char        = %zu 字节\n", sizeof(char));
    printf("short       = %zu 字节\n", sizeof(short));
    printf("int         = %zu 字节\n", sizeof(int));
    printf("long        = %zu 字节\n", sizeof(long));
    printf("long long   = %zu 字节\n", sizeof(long long));
    printf("float       = %zu 字节\n", sizeof(float));
    printf("double      = %zu 字节\n", sizeof(double));
    printf("long double = %zu 字节\n", sizeof(long double));
    return 0;
}

🟡 练习 2：类型安全计数器

编写一个函数 void safe_increment(uint8_t *counter)，接受一个 uint8_t 指针作为计数器。如果计数器没有达到最大值（255），则加 1；否则打印 "overflow" 并保持值不变。在主函数中演示从 253 加到 256 的过程（注意 256 无法用 uint8_t 表示）。

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

void safe_increment(uint8_t *counter) {
    if (*counter == UINT8_MAX) {
        printf("overflow! 计数器已达最大值 %" PRIu8 "\n", *counter);
    } else {
        (*counter)++;
    }
}

int main(void) {
    uint8_t counter = 253;
    for (int i = 0; i < 4; i++) {
        printf("当前值: %" PRIu8 "  → ", counter);
        safe_increment(&counter);
        printf("结果: %" PRIu8 "\n", counter);
    }
    return 0;
}

当前值: 253  → 结果: 254
当前值: 254  → 结果: 255
当前值: 255  → overflow! 计数器已达最大值 255
当前值: 255  → overflow! 计数器已达最大值 255

🔴 练习 3：自定义类型信息结构体

定义一个结构体 TypeInfo { const char *name; size_t bytes; long long min_val; unsigned long long max_val; }，编写函数 print_type_info(TypeInfo info) 来格式化打印类型信息。然后为 int8_t、int16_t、int32_t、int64_t、uint8_t 创建 TypeInfo 实例并打印。

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

typedef struct {
    const char       *name;
    size_t           bytes;
    long long        min_val;
    unsigned long long max_val;
} TypeInfo;

void print_type_info(TypeInfo info) {
    printf("  %-10s | %zu 字节 | min: %20lld | max: %20llu\n",
           info.name, info.bytes, info.min_val, info.max_val);
}

int main(void) {
    TypeInfo types[] = {
        {"int8_t",   sizeof(int8_t),   SCHAR_MIN,     UCHAR_MAX},
        {"int16_t",  sizeof(int16_t),  SHRT_MIN,      USHRT_MAX},
        {"int32_t",  sizeof(int32_t),  INT_MIN,       (unsigned)INT_MAX},
        {"int64_t",  sizeof(int64_t),  LLONG_MIN,     ULLONG_MAX},
        {"uint8_t",  sizeof(uint8_t),  0,             UCHAR_MAX},
    };

    int count = sizeof(types) / sizeof(types[0]);
    printf("  类型       | 字节数 | 最小值               | 最大值               \n");
    printf("  -----------|--------|----------------------|----------------------\n");

    for (int i = 0; i < count; i++) {
        print_type_info(types[i]);
    }
    return 0;
}

故障排查 (FAQ)

Q: 为什么 int 在我的电脑上是 4 字节，但在别人的电脑上是 2 字节？

A: C 标准只规定了 short ≤ int ≤ long ≤ long long 的相对大小，不规定绝对值。使用 <stdint.h> 中的 int32_t 等精确宽度类型可以避免这个问题。

Q: sizeof 返回的是什么类型？为什么我用 %d 打印会有警告？

A: sizeof 返回 size_t 类型（通常等同于 unsigned long 或 unsigned long long）。应该用 %zu 格式打印：printf("%zu\n", sizeof(int))。

Q: float 和 double 在什么情况下应该选择 float？

A: 三种情况：(1) 大量数据存储时节省内存；(2) GPU 编程中 float 通常比 double 快；(3) 嵌入式系统内存受限。其他情况，用 double。

Q: char 到底是有符号还是无符号？

A: C 标准没有规定，取决于你的平台。x86 上通常是 signed，ARM 上通常是 unsigned。如果需要明确的行为，始终用 signed char 或 unsigned char。

知识扩展 (选学)

类型别名与 typedef

你可以用 typedef 为已有类型创建别名，这在项目中非常常见：

typedef uint32_t pixel_t;    // 定义一个表示像素的类型
typedef uint8_t  byte_t;     // byte_t 就是 uint8_t 的别名

pixel_t color = 0xFF0000;    // 比 uint32_t 更具语义

浮点数精度问题

float 和 double 使用 IEEE 754 标准表示，不能精确表示所有小数：

double x = 0.1 + 0.2;
printf("%.20f\n", x);  // 输出: 0.30000000000000004000，不是 0.3！

我的建议：比较浮点数时，不要直接用 ==，而是用误差范围：

#include <math.h>
if (fabs(a - b) < 1e-9) {
    // a 和 b 在误差范围内相等
}

_Bool 类型（C99 起）

C99 引入了 _Bool 类型，<stdbool.h> 提供了更友好的别名 bool：

#include <stdbool.h>

bool is_ready = true;
if (is_ready) {
    printf("Ready!\n");
}

小结

本章介绍了 C 语言的核心数据类型体系：

关键术语：

• 精确宽度类型：intN_t，保证在所有平台上大小一致
• 溢出：数值超出类型范围，导致不可预期的行为
• 格式化宏：PRIdN 系列，用于正确打印精确宽度类型
• IEEE 754：浮点数的标准表示方式

术语表

延伸阅读

• C99 标准 — <stdint.h>：cppreference — Fixed width integer types
• 浮点数陷阱：What Every Programmer Should Know About Floating-Point Arithmetic
• C 语言极限常量：cppreference — limits.h
• C 语言类型系统：ISO/IEC 9899:2018, §6.2.5 Types

继续学习

• 上一章：变量与表达式
• 下一章：函数

本章代码位于仓库 src/basic/datatype.c 和 src/basic/datatype_sample.c。 运行 make build && make run 查看完整演示输出。

函数（Functions）

"代码应该像一首诗，函数就是它的韵律。" —— 我发现

开篇故事

走进一家专业厨房，你会看到切菜台、灶台、烘焙区各自独立，每个岗位有专门的厨师。如果让一个厨师同时切菜、炒菜、装盘，不仅手忙脚乱，出一盘菜的时间会被拉长好几倍。分工，是效率的来源。

C 语言的函数就是厨房里的分工。把一段代码打包成一个函数，等于在程序里开了一个专门的工作台。main() 不必包办一切——它只需要调度：调用 calculate() 算结果，调用 print_result() 打输出，调用 save_data() 存数据。每个函数只做一件事，但把这件事做好。代码从「一锅粥」变成了「流水线」，改一处不再崩三处。

函数，就是把复杂问题切分成小块的艺术。

本章适合谁

• 学过变量和数据类型，但没用过函数的 C 初学者
• 写过几百行 main()，想学会拆分代码的人
• 想知道函数声明（declaration）和定义（definition）区别的人

你会学到什么

• 函数的声明与定义（Declaration vs. Definition）
• 参数传递：值传递（Pass by Value）
• 返回值（Return Value）与 void 函数
• 函数原型（Prototype）与前向声明（Forward Declaration）
• 递归（Recursion）入门
• static 函数的作用域

前置要求

• 了解 C 基本数据类型（int、float、char 等）
• 会写基本的 printf 和 scanf
• 能编译运行单个 .c 文件

如果你还没学变量，建议先看「变量」章节。

第一个例子：计算两个数的和

#include <stdio.h>

// 函数定义（Definition）
int add(int a, int b) {
    return a + b;
}

int main(void) {
    int x = 3, y = 5;
    int result = add(x, y);  // 函数调用（Call）
    printf("%d + %d = %d\n", x, y, result);
    return 0;
}

运行结果：

3 + 5 = 8

看起来很简单？但这里面有好几个关键概念，我们逐一拆解。

原理解析

1. 函数的组成部分

一个完整的函数包含四个部分：

2. 声明 vs. 定义

声明（Declaration）：告诉编译器"这个函数存在"，也叫函数原型（Prototype）。

int add(int a, int b);  // 声明，以分号结尾

定义（Definition）：包含完整的函数体，是实际实现。

int add(int a, int b) {  // 定义，有函数体
    return a + b;
}

为什么需要声明？ 因为 C 编译器从上往下读代码。如果 main() 在 add() 前面调用它，编译器还不认识 add。

3. 前向声明（Forward Declaration）

#include <stdio.h>

// 前向声明：在 main 之前告诉编译器 max 存在
int max(int a, int b);

int main(void) {
    int result = max(10, 20);  // 编译器已认识 max
    printf("max = %d\n", result);
    return 0;
}

// 函数定义放在 main 之后
int max(int a, int b) {
    return (a > b) ? a : b;
}

4. void 函数

不是所有函数都需要返回值。void 表示"无返回"。

void print_separator(int length) {
    for (int i = 0; i < length; i++) {
        putchar('-');
    }
    putchar('\n');
}

5. 值传递（Pass by Value）

C 语言的参数默认是值传递——函数拿到的是原值的副本，修改不会影响原变量。

void try_to_modify(int x) {
    x = 100;  // 只改了副本，不影响原值
}

int main(void) {
    int a = 5;
    try_to_modify(a);
    printf("a = %d\n", a);  // 输出: a = 5
    return 0;
}

常见错误

❌ 错误 1：函数返回类型不匹配

// 错误：声明为 int，但返回了字符串
int get_name(void) {
    return "hello";  // ❌ 编译错误：incompatible types
}

✅ 修正：返回类型要与实际返回值一致。

const char *get_name(void) {
    return "hello";  // ✅ 正确
}

❌ 错误 2：忘记写 return

int add(int a, int b) {
    a + b;  // ❌ 计算了但没返回！控制到达非 void 函数末尾
}

✅ 修正：使用 return 关键字。

int add(int a, int b) {
    return a + b;  // ✅ 正确
}

❌ 错误 3：参数名在声明中与定义中不一致

虽然参数名可以不同，但类型必须一致：

// 声明
double divide(double a, double b);

// 定义 — 名字不同没问题，但类型必须一致
double divide(double x, double y) {  // ✅ 正确，类型一致
    if (y != 0.0) {
        return x / y;
    }
    return 0.0;
}

动手练习

🟢 练习 1：实现 swap_display 函数

// 写一个函数，接收两个 int，按从小到大的顺序打印它们

void swap_display(int a, int b) {
    if (a > b) {
        printf("从小到大: %d, %d\n", b, a);
    } else {
        printf("从小到大: %d, %d\n", a, b);
    }
}

🟡 练习 2：实现 factorial 函数（递归版）

// 写一个递归函数，计算 n 的阶乘（n!）
// factorial(5) = 5 * 4 * 3 * 2 * 1 = 120

long long factorial(int n) {
    if (n <= 1) {
        return 1;
    }
    return (long long)n * factorial(n - 1);
}

🔴 练习 3：实现 is_prime 函数

// 写一个函数，判断一个正整数是否为素数
// is_prime(7)  = 1 (true)
// is_prime(12) = 0 (false)

int is_prime(int n) {
    if (n <= 1) {
        return 0;
    }
    if (n <= 3) {
        return 1;
    }
    if (n % 2 == 0 || n % 3 == 0) {
        return 0;
    }
    for (int i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) {
            return 0;
        }
    }
    return 1;
}

故障排查（FAQ）

Q: 函数可以返回数组吗？

不能直接返回。C 语言中数组不是"一等公民"。你可以返回指针（指向静态数组或动态分配的内存），但不能直接返回数组类型。

// ✅ 正确：返回指向静态数组的指针
const int *get_numbers(void) {
    static int arr[] = {1, 2, 3};
    return arr;
}

Q: return 能返回多个值吗？

不能。但你可以用结构体（struct）包装多个值返回，或者通过指针参数修改原变量（后续章节会讲）。

Q: 函数的参数名必须在声明和定义中一致吗？

不需要。编译器只关心参数类型和数量。但推荐保持一致以提高可读性。

Q: 函数中可以再定义函数吗？

C 语言不支持嵌套函数定义。但你可以嵌套调用函数。

知识扩展（选学）

_Noreturn 属性（C11）

C11 引入了 _Noreturn 关键字，告诉编译器这个函数永远不会返回：

#include <stdlib.h>

_Noreturn void fatal_error(const char *msg) {
    fprintf(stderr, "Fatal: %s\n", msg);
    exit(EXIT_FAILURE);
}

使用 _Noreturn 可以让编译器生成更精确的警告。

static 函数（内部链接）

给函数加 static 关键字，可以限制函数只在当前文件可见：

// file_utils.c

static int validate_path(const char *path) {
    // 仅本文件可调用，不会污染全局命名空间
    return (path != NULL && path[0] == '/');
}

int open_file(const char *path) {
    if (!validate_path(path)) {
        return -1;
    }
    // ... 打开文件
    return 0;
}

小结

恭喜你学完了 C 语言函数的核心概念！让我们回顾一下——

• 函数 = 返回类型 + 函数名 + 参数列表 + 函数体
• 声明（Prototype）告诉编译器函数存在，定义包含完整实现
• 前向声明解决了"先调用后定义"的问题
• void 函数不返回值，但仍然可以提前退出（return;）
• C 语言参数传递是值传递，函数内修改不影响原变量
• _Noreturn 和 static 是进阶特性，能让代码更安全、更模块化

术语表

延伸阅读

• cppreference: Functions in C
• Beej's Guide to C: Functions
• K&R《C 程序设计语言》第 1.7、4 章
• 《C Primer Plus》第 9 章：函数

继续学习

函数是 C 语言模块化的基础。下一章我们将学习运算符与表达式，了解 C 语言中丰富的运算符以及它们的优先级规则——这将让你写出更简洁、更精准的代码。

💡 提示：试试把之前写的代码改写成函数形式！把你的 main() 拆成 3-5 个函数，你会发现代码立刻变清爽了。

运算符与表达式（Operators & Expressions）

"运算符是 C 语言的动词，决定了数据之间如何交互。" —— 我发现

开篇故事

修理工的工具箱里有扳手、螺丝刀、钳子、锤子。扳手拧螺母，螺丝刀拧螺丝，锤子敲钉子。每种工具负责一种操作，但它们的区别不在于外观，而在于「对物体做了什么」。选错工具，拧螺母用锤子只会把活搞砸。

C 语言的运算符就是这样的工具箱。+ 是加法扳手，/ 是除号螺丝刀，== 是比较钳子，&& 是逻辑锤子。它们看似简单，但优先级、结合性和短路求值这些特性就像工具的受力方向——用法不对，结果就可能出乎意料。比如把赋值 = 写成比较 ==，就像把扳手当锤子敲下去，程序不会报错，但干的是另一件事。

运算符是 C 语言的动词，它们决定了数据之间如何交互。理解了运算符，你才能真正让数据为你工作。

本章适合谁

• 学过基本数据类型和变量的人
• 写过程序，但对 ++i 和 i++ 有什么区别说不清楚的人
• 在条件判断中踩过运算符坑的朋友

你会学到什么

• 算术运算符（Arithmetic）：+、-、*、/、%
• 关系运算符（Relational）：==、!=、<、>、<=、>=
• 逻辑运算符（Logical）：&&、||、!
• 位运算符（Bitwise）：&、|、^、~、<<、>>
• 赋值运算符（Assignment）：=, +=, -=, *=, /=, %=
• 运算符优先级与结合性
• 短路求值（Short-circuit Evaluation）

前置要求

• 了解整数类型（int、long）和浮点类型（float、double）
• 了解二进制基础（对位运算章节有帮助）
• 会写简单的 if 判断

第一个例子：基础算术运算

#include <stdio.h>

int main(void) {
    int a = 17, b = 5;

    printf("a = %d, b = %d\n", a, b);
    printf("a + b = %d\n", a + b);   // 加法:  22
    printf("a - b = %d\n", a - b);   // 减法:  12
    printf("a * b = %d\n", a * b);   // 乘法:  85
    printf("a / b = %d\n", a / b);   // 除法:  3  (整数除法!)
    printf("a %% b = %d\n", a % b);   // 取余:  2

    return 0;
}

运行结果：

a = 17, b = 5
a + b = 22
a - b = 12
a * b = 85
a / b = 3
a % b = 2

关键发现：a / b = 3 不是 3.4！因为这是整数除法，小数部分被截断了。

原理解析

1. 算术运算符（Arithmetic Operators）

注意：/ 和 % 的行为取决于操作数类型。两个整数之间使用 / 是整数除法，只要有一个是浮点数就是浮点除法。

int a = 7 / 2;        // a = 3
double b = 7.0 / 2;   // b = 3.5

2. 关系运算符（Relational Operators）

返回 1（真）或 0（假）：

3. 逻辑运算符（Logical Operators）

短路求值（Short-circuit evaluation）：

int x = 0;
if (x != 0 && 10 / x > 2) {
    // 永远不会执行到这里——不会除零
    // 因为 x != 0 为假，&& 左边的条件失败后，右边不再求值
}

4. 位运算符（Bitwise Operators）

对二进制位进行操作：

常见用法：

// 判断奇偶（比 % 2 更快）
int is_odd = (n & 1);

// 乘以 2 的幂（左移）
int x = 5;
int y = x << 3;  // y = 5 * 8 = 40

// 设置/清除特定位
unsigned char flags = 0x00;
flags |= (1 << 3);   // 设置第 3 位: 0x08
flags &= ~(1 << 3);  // 清除第 3 位: 0x00

5. 赋值运算符（Assignment Operators）

6. 运算符优先级（Precedence）

部分优先级（从高到低）：

黄金法则：如果你不确定优先级，加括号。a + b * c → a + (b * c) 更清晰。

常见错误

❌ 错误 1：= vs ==

int x = 5;
if (x = 10) {  // ❌ 这是赋值，不是比较！
    printf("x is 10\n");  // 总是会打印
}

✅ 修正：使用 == 进行比较。

int x = 5;
if (x == 10) {  // ✅ 正确比较
    printf("x is 10\n");  // 不会打印
}

防御性编程技巧：把常量写在左边——if (10 == x)。如果误写成 = 编译器会报错，因为不能给字面量赋值。

❌ 错误 2：整数除法陷阱

double result;
result = 1 / 2;      // ❌ result = 0.0（整数除法先算，再转 double）
result = 1.0 / 2;    // ✅ result = 0.5（浮点除法）
result = (double)1 / 2;  // ✅ 也正确，强制类型转换

❌ 错误 3：& 和 && 混淆

int a = 5, b = 3;
if (a & b) {  // ❌ 这是按位与: 5 & 3 = 1（真），但不是逻辑意图
    printf("true\n");
}

if (a && b) {  // ✅ 逻辑与: 两个非零值都为真
    printf("true\n");
}

两者都可能返回"真"，但在复杂条件下行为不同：

• && 会短路（左边为假不计算右边）
• & 不会短路（两边始终计算）

动手练习

🟢 练习 1：判断年份是否为闰年

// 闰年规则：
// 能被 4 整除但不能被 100 整除，或者能被 400 整除
// is_leap_year(2024) = 1
// is_leap_year(1900) = 0
// is_leap_year(2000) = 1

int is_leap_year(int year) {
    return ((year % 4 == 0) && (year % 100 != 0))
        || (year % 400 == 0);
}

🟡 练习 2：不用第三个变量交换两个整数

// 使用异或运算符 ^ 来交换两个变量的值
// 不能创建第三个变量
void swap_xor(int *a, int *b);

void swap_xor(int *a, int *b) {
    if (a == b) {
        return;  // 防止自己跟自己异或结果为 0
    }
    *a = *a ^ *b;
    *b = *a ^ *b;  // *b = (*a ^ *b) ^ *b = *a
    *a = *a ^ *b;  // *a = (*a ^ *b) ^ *a = *b
}

🔴 练习 3：实现位域（Bitfield）操作函数

// 给定一个 unsigned int flags：
// 1. set_bit(flags, pos)    — 设置第 pos 位为 1
// 2. clear_bit(flags, pos)  — 清除第 pos 位为 0
// 3. toggle_bit(flags, pos) — 翻转第 pos 位
// 4. get_bit(flags, pos)    — 获取第 pos 位的值（0 或 1）

unsigned int set_bit(unsigned int flags, int pos) {
    return flags | (1u << pos);
}

unsigned int clear_bit(unsigned int flags, int pos) {
    return flags & ~(1u << pos);
}

unsigned int toggle_bit(unsigned int flags, int pos) {
    return flags ^ (1u << pos);
}

int get_bit(unsigned int flags, int pos) {
    return (flags >> pos) & 1;
}

故障排查（FAQ）

Q: ++i 和 i++ 有什么区别？

++i（前缀）先加后用，i++（后缀）先用后加：

int i = 5;
int a = ++i;  // a = 6, i = 6（先增后赋值）
int b = i++;  // b = 6, i = 7（先赋值后增）

Q: % 运算符可以对负数使用吗？

可以，但结果符号取决于被除数（C 语言标准定义）：

printf("%d\n",  7 % -3);   // 输出:  1
printf("%d\n", -7 %  3);   // 输出: -1
printf("%d\n",  7 %  3);   // 输出:  1

Q: 位运算符可以操作浮点数吗？

不能。位运算符只适用于整数类型。

Q: 为什么 a += b * c 的结果不是 (a + b) * c？

因为赋值运算符的优先级几乎最低。a += b * c 等价于 a += (b * c)，而不是 (a + b) * c。

知识扩展（选学）

三元运算符（Ternary Operator）

int max = (a > b) ? a : b;
// 等价于:
// if (a > b) { max = a; } else { max = b; }

可以嵌套（但不推荐）：

// 三个数中找最大值
int max3 = (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);

逗号运算符

逗号运算符 , 从左到右依次求值，返回最右边的值：

int result = (a = 5, b = 10, a + b);  // result = 15

注意：这里的逗号与函数参数分隔符不同。int func(a, b) 中的逗号不是逗号运算符。

sizeof 运算符

sizeof 返回类型或变量的字节大小：

printf("int 的大小: %zu 字节\n", sizeof(int));
printf("double 的大小: %zu 字节\n", sizeof(double));
// sizeof 是一个编译期运算符，不是函数！

小结

这一章我们走过了 C 语言的运算符大家族——

• 算术运算符：+、-、*、/、%—注意整数除法与浮点除法的区别
• 关系运算符：==、!=、<、>、<=、>=—返回 1 或 0
• 逻辑运算符：&&、||、!—理解短路求值
• 位运算符：&、|、^、~、<<、>>—二进制位操作的基础
• 赋值运算符：=, +=, -= 等—复合赋值的简洁写法
• 优先级很重要，但不确定时加括号是最安全的做法

术语表

延伸阅读

• cppreference: Operators in C
• C Operator Precedence Table
• Hacker's Delight（《算法心得》）— 位运算的经典之作
• K&R《C 程序设计语言》第 2 章

继续学习

掌握了运算符，你已经能写出丰富的表达式了！下一章我们将学习数组基础，了解如何在 C 语言中存储和处理一组相关数据。

💡 提示：试着用位运算符实现一个小的"标志寄存器"，用一个 int 管理多个开关状态。这在嵌入式开发中非常常见！

数组基础 (Arrays)

想象一栋公寓楼的外墙，上面整齐排列着几十个信箱。每个信箱大小相同，门牌号从 0 开始依次编号。邮递员只看门牌号投递——mailbox[0]、mailbox[1]、mailbox[2]，依此类推。所有信箱格式一样，装的都是信件，不会混放包裹。

这就是 C 语言数组的形态。一块连续的内存空间，分成若干大小相同的格子，用整数索引编号。格子大小由你声明的类型决定——int32_t scores[5] 就是 5 个同样大小的 int32_t 格子。这种设计让读写非常高效，计算索引地址只需要简单的乘法和加法。

但公寓管理员有一个特殊规矩：他不盯着你按门牌号办事。你想开 mailbox[5] 这扇门，他不会拦你——但这扇门后面可能是走廊、邻居的墙，或者什么都没有。C 语言不检查数组越界，它信任你。这份信任换来的是速度和灵活，也意味着你必须自己管好边界。

C 语言把选择权交给程序员，也把责任交给你。

本章适合谁

• 已经了解 C 语言基本变量（int32_t、double 等）
• 想理解"一组相同类型的数据"如何存储和操作
• 被数组越界 bug 折磨过的程序员（我当初就是 😅）

你会学到什么

• 一维数组的声明和初始化
• {...} 初始化语法（全部初始化、部分初始化、省略长度）
• 数组索引（0-based）与边界
• 遍历数组的循环模式
• sizeof(array) / sizeof(element) 计算元素个数
• 常见错误：越界访问、混淆大小写索引

前置要求

完成 变量 和 数据类型 章节。

第一个例子

让我先展示一个完整的数组程序：

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

int main(void) {
    // 声明并初始化
    int32_t scores[5] = {85, 92, 78, 96, 88};

    // 计算元素个数
    int32_t count = (int32_t)(sizeof(scores) / sizeof(scores[0]));

    // 遍历打印
    for (int32_t i = 0; i < count; i++) {
        printf("学生 %d: %d 分\n", i + 1, scores[i]);
    }

    return 0;
}

输出：

学生 1: 85 分
学生 2: 92 分
学生 3: 78 分
学生 4: 96 分
学生 5: 88 分

分步解析

1. int32_t scores[5]：声明一个能存 5 个 int32_t 的数组
2. {85, 92, 78, 96, 88}：初始值列表
3. sizeof(scores) / sizeof(scores[0])：总字节数 ÷ 单个元素字节数 = 元素个数
4. scores[i]：通过索引访问第 i 个元素

原理解析

内存布局

数组在内存中是连续存储的：

scores: [85] [92] [78] [96] [88]
         ↑    ↑    ↑    ↑    ↑
       [0]  [1]  [2]  [3]  [4]

每个元素占 4 字节（int32_t）。scores[0] 的地址是数组的起始地址，scores[1] 的地址则是 起始地址 + 4 字节。

三种初始化方式

// 方式 1: 全部初始化（指定长度）
int32_t a[5] = {1, 2, 3, 4, 5};

// 方式 2: 省略长度（编译器根据初始值推导）
int32_t b[] = {1, 2, 3, 4, 5};  // 长度 = 5

// 方式 3: 部分初始化（其余自动为 0）
int32_t c[5] = {1, 2};         // c = {1, 2, 0, 0, 0}

sizeof 技巧

这是我最常用的数组技巧：

int32_t data[] = {1, 2, 3, 4, 5, 6, 7, 8};
size_t count = sizeof(data) / sizeof(data[0]);
// sizeof(data) = 32 (8 个 × 4 字节)
// sizeof(data[0]) = 4
// count = 32 / 4 = 8

⚠️ 注意: 这个技巧只对数组本身有效。当数组传给函数后，它会退化为指针，sizeof 得到的是指针的大小（8 字节在 64 位机器上），不再是整个数组。

常见错误

❌ 错误 1: 数组越界

int32_t arr[3] = {10, 20, 30};

// ❌ 越界访问：索引 3 超出范围
printf("%d\n", arr[3]);   // 未定义行为！可能崩溃，可能打印垃圾值

编译器通常不会拦截这个错误。修复方式：

int32_t arr[3] = {10, 20, 30};
// ✅ 合法索引: 0 ~ 2
for (int32_t i = 0; i < 3; i++) {
    printf("arr[%d] = %d\n", i, arr[i]);
}

❌ 错误 2: 初始化时长度不匹配

// ❌ 编译器可能警告，但不一定报错
int32_t arr[2] = {1, 2, 3, 4};  // 4 个值塞进 2 个容量！

修复：

// ✅ 让编译器推导长度，或者给够长度
int32_t arr[] = {1, 2, 3, 4};   // 长度 = 4
// 显式指定
int32_t arr2[4] = {1, 2, 3, 4};

❌ 错误 3: 在函数中用 sizeof 获取数组长度

void print_size(int32_t arr[]) {
    // ❌ arr 在这里退化成了指针！
    size_t count = sizeof(arr) / sizeof(arr[0]);  // 8 / 4 = 2（错误！）
    printf("%zu\n", count);
}

修复方案——把长度当参数传进来：

void print_size(int32_t arr[], int32_t count) {
    // ✅ 从参数获取长度
    for (int32_t i = 0; i < count; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }
}

int main(void) {
    int32_t data[] = {1, 2, 3, 4, 5};
    int32_t count = (int32_t)(sizeof(data) / sizeof(data[0]));
    print_size(data, count);
    return 0;
}

动手练习

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

int main(void) {
    int32_t nums[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int64_t sum = 0;
    for (int32_t i = 0; i < 10; i++) {
        sum += nums[i];
    }
    printf("总和: %lld\n", (long long)sum);
    return 0;
}

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

int main(void) {
    int32_t arr[] = {1, 2, 3, 4, 5};
    int32_t n = (int32_t)(sizeof(arr) / sizeof(arr[0]));

    for (int32_t i = 0; i < n / 2; i++) {
        int32_t temp = arr[i];
        arr[i] = arr[n - 1 - i];
        arr[n - 1 - i] = temp;
    }

    for (int32_t i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

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

int main(void) {
    int32_t arr[] = {12, 35, 1, 10, 35, 1};
    int32_t n = (int32_t)(sizeof(arr) / sizeof(arr[0]));

    int32_t max = INT32_MIN;
    int32_t second = INT32_MIN;

    for (int32_t i = 0; i < n; i++) {
        if (arr[i] > max) {
            second = max;
            max = arr[i];
        } else if (arr[i] > second && arr[i] != max) {
            second = arr[i];
        }
    }

    if (second == INT32_MIN) {
        printf("不存在第二大元素（所有元素相同）\n");
    } else {
        printf("第二大元素: %d\n", second);
    }
    return 0;
}

故障排查 (FAQ)

int32_t arr[5];  // ❌ 每个元素的值是垃圾值
printf("%d\n", arr[0]);  // 随机数！

int32_t arr[5] = {0};  // ✅ 所有元素都是 0
// 或者
int32_t arr[5] = {0, 0, 0, 0, 0};

int32_t a[] = {1, 2, 3};
int32_t b[] = {1, 2, 3};
// a == b 比较地址！结果是 false。

#include <string.h>
#include <stdbool.h>

int same = (memcmp(a, b, sizeof(a)) == 0) ? 1 : 0;
// 1 表示内容相同

知识扩展 (选学)

变长数组 (VLA) — C99 引入

int32_t n = 10;
int32_t arr[n];  // 运行时确定大小 (C99+)

注意: C11 开始 VLA 变为可选特性，部分编译器（如 MSVC）不支持。不推荐在生产代码中使用。

多维数组

C 支持二维及更高维度的数组：

int32_t matrix[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

printf("%d\n", matrix[1][2]);  // 输出 6 (第 2 行，第 3 列)

小结

这一章我发现：

• 数组是连续内存，索引从 0 开始
• 声明时可以用 {...} 初始化，支持部分初始化和省略长度
• sizeof(array) / sizeof(array[0]) 是计算元素个数的标准做法
• 越界访问是未定义行为——编译器不负责拦截，要靠自己小心
• 数组传给函数后会退化为指针，需要单独传长度

术语表

延伸阅读

• C99 标准 §6.7.8 — 数组初始化
• memcpy / memcmp / memmove —— <string.h> 中的内存操作函数
• 下一章: 控制流 — if/else 分支与 switch 语句

继续学习

控制流：if/else/switch

站在一个十字路口，红绿灯控制着车流方向。绿灯直行，红灯停下，左转箭头亮起时走左转道。信号灯不关心车里坐的是谁，只看当前状态决定放行。

if (rain) {
    bring_umbrella();
} else {
    wear_sunglasses();
}

我意识到，原来我可以让程序自己做决定。控制流就是程序的"大脑"——它负责选择走哪条路、什么时候重复、什么时候停下来。

开篇故事

站在一个十字路口，红绿灯控制着车流方向。绿灯时直行，红灯时停下，左转箭头亮起时走左转道。交通信号灯不关心你车里坐的是谁，它只根据当前状态决定放行路线。每一辆车都在做同样的事情：看灯，选路。

程序的执行也是如此。默认情况下，代码从上到下依次执行，像直行通过一个十字路口。但现实世界充满了分支——下雨就带伞，天晴就戴太阳镜。C 语言的 if、else、switch 就是程序的红绿灯。它们根据条件的真假，让执行路径走向不同的分支。没有控制流，程序只是机械地念台词；有了控制流，程序才开始做选择。

控制流就是程序的"大脑"——它负责选择走哪条路、什么时候重复、什么时候停下来。

人生最重要的不是站在原地，而是知道在岔路口往哪走。——改编自 罗杰·贝肯

本章适合谁

• 已经掌握变量、数组和基本输入输出
• 想让程序根据条件做出不同响应
• 想理解 "missing break" 和 "dangling else" 为什么会导致难以追踪的 bug

你会学到什么

• if / else if / else 分支结构
• switch / case / default + break 的重要性
• 三元运算符 ?: 的简洁写法
• 嵌套条件和悬挂 else 问题
• 常见陷阱：忘记 break、条件赋值与比较混淆

前置要求

完成 变量 和 运算符 章节。

第一个例子

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

int main(void) {
    int32_t score = 85;

    if (score >= 90) {
        printf("优秀 (A)\n");
    } else if (score >= 80) {
        printf("良好 (B)\n");
    } else if (score >= 60) {
        printf("及格 (C)\n");
    } else {
        printf("不及格 (F)\n");
    }

    return 0;
}

输出：

良好 (B)

分步解析

1. if (score >= 90) —— 先检查最高档
2. else if (score >= 80) —— 90 不满足，继续往下
3. score >= 80 为真，打印 "良好 (B)"，然后跳过剩余分支

原理解析

if / else / else if 结构

if (条件1) {
    // 条件1 为真 → 执行这里
} else if (条件2) {
    // 条件1 为假, 条件2 为真 → 执行这里
} else {
    // 所有条件都不为真 → 执行这里
}

执行流程像瀑布——从上往下逐层判断，一旦命中就跳过其余。

switch / case

当需要根据一个整数的多个可能值选择分支时，switch 更清晰：

int32_t day = 3;

switch (day) {
    case 1: printf("星期一\n"); break;
    case 2: printf("星期二\n"); break;
    case 3: printf("星期三\n"); break;
    default: printf("无效编号！\n"); break;
}

三元运算符 ?:

int32_t age = 20;
const char *status = (age >= 18) ? "成年人" : "未成年人";

等价于：

const char *status;
if (age >= 18) {
    status = "成年人";
} else {
    status = "未成年人";
}

三元运算符适合简单的二选一赋值，但别嵌套——一旦嵌套三层以上，代码就变成天书了。

常见错误

❌ 错误 1: switch 中忘记 break

int32_t choice = 1;

// ❌ 没有 break → fall-through (穿透)
switch (choice) {
    case 1:
        printf("选项 A\n");
    case 2:
        printf("选项 B\n");
    default:
        printf("默认选项\n");
}
/*
输出:
  选项 A
  选项 B
  默认选项
*/

修复：

// ✅ 每个 case 末尾加 break
switch (choice) {
    case 1:
        printf("选项 A\n");
        break;
    case 2:
        printf("选项 B\n");
        break;
    default:
        printf("默认选项\n");
        break;
}

例外：有时故意穿透是合理的（如多月共享同一天数的逻辑），但要加注释。

❌ 错误 2: 条件中使用 = 而非 ==

int32_t x = 5;

// ❌ 这是赋值！不是比较。x 被赋值为 0，条件为假
if (x = 0) {
    printf("x 是零。\n");
}

编译器（带 -Wall）会警告，但如果忽略警告就会发现 bug。我的习惯：

// ✅ Yoda condition —— 如果写成 = 会编译报错
if (0 == x) {
    printf("x 是零。\n");
}

或者养成用 == 的习惯即可。

❌ 错误 3: 悬挂 else (Dangling Else)

int32_t a = 5, b = 10;

// ❌ else 属于哪个 if？C 的规则是"就近匹配"
if (a > 3)
    if (b > 20)
        printf("b > 20\n");
else
    printf("这个 else 属于内层 if (b > 20)！\n");

修复——永远用花括号：

// ✅ 明确匹配关系
if (a > 3) {
    if (b > 20) {
        printf("b > 20\n");
    }
} else {
    printf("这个 else 属于外层 if (a > 3)。\n");
}

动手练习

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

int main(void) {
    int32_t n = 7;

    if (n % 2 == 0) {
        printf("%d 是偶数。\n", n);
    } else {
        printf("%d 是奇数。\n", n);
    }

    return 0;
}

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

int main(void) {
    double a = 10.0, b = 3.0;
    char op = '/';

    switch (op) {
        case '+':
            printf("%.2f + %.2f = %.2f\n", a, b, a + b);
            break;
        case '-':
            printf("%.2f - %.2f = %.2f\n", a, b, a - b);
            break;
        case '*':
            printf("%.2f * %.2f = %.2f\n", a, b, a * b);
            break;
        case '/':
            if (b != 0.0) {
                printf("%.2f / %.2f = %.2f\n", a, b, a / b);
            } else {
                printf("错误: 除以零！\n");
            }
            break;
        default:
            printf("未知运算符: %c\n", op);
            break;
    }

    return 0;
}

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

bool is_leap_year(int32_t year) {
    if (year % 400 == 0) {
        return true;
    }
    if (year % 100 == 0) {
        return false;
    }
    if (year % 4 == 0) {
        return true;
    }
    return false;
}

int main(void) {
    int32_t years[] = {2024, 1900, 2000, 2023};
    int32_t n = (int32_t)(sizeof(years) / sizeof(years[0]));

    for (int32_t i = 0; i < n; i++) {
        const char *label = is_leap_year(years[i]) ? "闰年" : "平年";
        printf("%d: %s\n", years[i], label);
    }

    return 0;
}

2024: 闰年
1900: 平年
2000: 闰年
2023: 平年

故障排查 (FAQ)

int32_t x = 5;
switch (val) {
    case x:      // ❌ 编译错误
    case 5:      // ✅ 常量，可以
    case 2 + 3:  // ✅ 编译器能算出的常量，也可以
}

if (strcmp(name, "Alice") == 0) {
    // ...
} else if (strcmp(name, "Bob") == 0) {
    // ...
}

知识扩展 (选学)

Duff's Device —— switch 的极限用法

void send(int *to, int *from, int count) {
    int n = (count + 7) / 8;
    switch (count % 8) {
        case 0: do { *to++ = *from++;
        case 7:      *to++ = *from++;
        case 6:      *to++ = *from++;
        case 5:      *to++ = *from++;
        case 4:      *to++ = *from++;
        case 3:      *to++ = *from++;
        case 2:      *to++ = *from++;
        case 1:      *to++ = *from++;
                    } while (--n > 0);
    }
}

这是合法的 C 代码，利用了 switch 的 fall-through 特性做循环展开 (loop unrolling) 优化。日常几乎不需要，但知道后你会重新认识 switch 的灵活性。

守卫子句 (Guard Clause)

在函数开头尽早 return，避免深层嵌套：

// ❌ 深层嵌套
void process(int *data, int len) {
    if (data != NULL) {
        if (len > 0) {
            // 真正逻辑缩进很深
        }
    }
}

// ✅ 守卫子句
void process(int *data, int len) {
    if (data == NULL) return;
    if (len <= 0)     return;
    // 真正逻辑在这里，少了一层缩进
}

小结

通过这一章我发现：

• if / else if / else 是条件判断的基础结构——命中就执行，其余跳过
• switch / case 适合整数多分支场景，但别忘了 break
• 三元运算符 ?: 适合简单的二选一赋值，别嵌套使用
• 悬挂 else：C 的 else 就近匹配内层 if——用花括号消除歧义
• = 和 == 是常见的混淆源，编译器警告务必重视

术语表

延伸阅读

• C99 标准 §6.8.4 — 选择语句 (Selection statements)
• Duff's Device — 经典 C 优化技巧
• Guard clause — 维基百科
• 上一章: 数组基础

继续学习

循环：for / while / do-while

"我发现，循环就像生活中的重复劳动——掌握了它，你就能让计算机替你搬砖。" —— 我常犯的错

开篇故事

走进一条食品加工厂的生产线。第一道工序把面团揉好，第二道工序切块，第三道工序烘烤，第四道工序包装。同一批面团重复走过这条线，每分钟产出几十个面包。工人不需要一个个手工做面包——流水线替他们自动循环。

这就是循环（Loop）在编程中的作用。没有循环的时候，你要打印 100 行内容就得写 100 条语句，就像手工一个一个做面包。引入循环后，3 行代码搞定这件事——告诉计算机「做什么」和「做多少次」，剩下的它自己循环执行。

C 语言提供三种循环：for 适合已知次数的情景（做 100 个面包），while 适合条件驱动的未知次数（烘到金黄为止），do-while 适合至少执行一次的情景（先尝一口再决定要不要继续）。它们的核心思路一样：把重复的事情自动化。

重复是机器最擅长的事，把重复交给机器，你只管设计规则。——工业工程格言

本章适合谁

• 已经学过变量、运算符、控制流（if/else/switch）的 C 初学者
• 经常复制粘贴相似代码，想学会自动化重复的人
• 被 break、continue 搞晕过的人

你会学到什么

• for 循环：初始化、条件判断、递增三步曲
• while 循环：条件驱动的循环
• do-while 循环：至少执行一次的循环
• break 跳出循环与 continue 跳过本次迭代
• 嵌套循环（Nested Loops）与乘法表
• 循环不变量（Loop Invariant）概念
• 无限循环的安全使用
• 如何选择合适的循环类型

前置要求

• 了解 C 基本数据类型（int、double）
• 会使用 printf 输出
• 了解 if/else 条件判断

如果你还没学过控制流，建议先看「控制流」章节。

第一个例子：打印 1 到 5

#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 5; i++) {
        printf("%d ", i);
    }
    putchar('\n');
    return 0;
}

运行结果：

1 2 3 4 5

就这么简单！但你有没有想过 for 括号里三个部分各自在什么时候执行？让我帮你拆开看。

原理解析

1. for 循环：三步曲

for 循环是最常用的循环，语法如下：

for (初始化; 条件; 递增) {
    循环体;
}

执行顺序：

1. 初始化：只在循环开始前执行一次（声明循环变量 int i = 1）
2. 条件：每次循环开始前判断（i <= 5），为真则进入循环体，为假则退出
3. 循环体：执行 {} 中的代码
4. 递增：每次循环体结束后执行（i++），然后回到步骤 2

我常犯的错：把递增忘了写，结果变成死循环——for (int i = 1; i <= 5; )，i 永远是 1，条件永远为真。

/* 正确写法 */
for (int i = 1; i <= 5; i++) {
    printf("%d ", i);
}

/* 多变量写法——同时控制两个变量 */
for (int i = 0, j = 10; i < j; i++, j--) {
    printf("i=%d, j=%d\n", i, j);
}

2. while 循环：条件驱动

当循环次数未知时，while 是更好的选择：

while (条件) {
    循环体;
}

我的理解：while 就像在门口放个保安，每次进去前都要检查条件。如果一开始条件就是假的，循环体一次都不会执行。

/* 计算 1+2+...+100 */
int sum = 0;
int i = 1;          /* 初始化在循环外 */

while (i <= 100) {  /* 条件判断 */
    sum += i;
    i++;            /* 递增在循环体内——容易遗漏！ */
}

3. do-while 循环：至少执行一次

do {
    循环体;
} while (条件);

关键区别：do-while 先执行、后判断，所以循环体至少执行一次。常用于"先询问用户输入，再验证"的场景。

int input;

do {
    printf("请输入正数（输入 0 退出）：");
    scanf("%d", &input);
    if (input > 0) {
        printf("你输入了：%d\n", input);
    }
} while (input != 0);

4. break 与 continue

/* break: 找到第一个 3 的倍数就停止 */
for (int i = 1; i <= 10; i++) {
    if (i % 3 == 0) {
        printf("找到 %d，break！\n", i);
        break;
    }
}

/* continue: 跳过偶数，只打印奇数 */
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    printf("%d ", i);
}
/* 输出: 1 3 5 7 9 */

5. 嵌套循环

循环里再套循环，像俄罗斯套娃：

/* 九九乘法表 (1-5) */
for (int i = 1; i <= 5; i++) {        /* 外层：行 */
    for (int j = 1; j <= i; j++) {    /* 内层：列 */
        printf("%d×%d=%-4d", j, i, i * j);
    }
    putchar('\n');
}

我的理解：外层循环每走一步，内层循环要跑完一整圈。外层 5 次 × 内层平均 3 次 = 大约 15 次迭代。

6. 循环不变量（Loop Invariant）

循环不变量是指：在每次循环迭代前后都保持为真的条件。它帮助我们证明循环的正确性。

/* 找数组最大值 */
int arr[] = {3, 7, 2, 9, 1};
int max = arr[0];

for (int i = 1; i < 5; i++) {
    /* 不变量：max 始终是 arr[0..i-1] 中的最大值 */
    if (arr[i] > max) {
        max = arr[i];
    }
}
/* 循环结束后：max 是 arr[0..4] 中的最大值 → 9 */

7. 无限循环与安全退出

/* 安全写法：无限循环 + break */
for (;;) {
    /* 做某件事 */
    if (某个条件) {
        break;  /* 必须有退出机制！ */
    }
}

/* 同样安全的 while(1) 写法 */
while (1) {
    /* 做某件事 */
    if (某个条件) {
        break;
    }
}

我常犯的错：写 while(1) 时忘了写 break，程序卡死。所以写无限循环时，我会在循环体第一行就写下 if (...) break;，防止忘记。

8. 如何选择合适的循环类型

常见错误

❌ 错误 1：for 循环漏写递增，导致死循环

for (int i = 1; i <= 5; ) {
    printf("%d ", i);
    /* 忘了 i++，i 永远是 1，无限循环！ */
}

编译器不会报错——语法完全正确，但程序会卡死。

✅ 修正：补上递增语句。

for (int i = 1; i <= 5; i++) {  /* ✅ 加上 i++ */
    printf("%d ", i);
}

❌ 错误 2：do-while 漏写分号

do {
    printf("hello\n");
} while (x < 5)  /* ❌ 编译错误：expected ';' before '}' token */

✅ 修正：do-while 的 while(...) 后必须有分号。

do {
    printf("hello\n");
} while (x < 5);  /* ✅ 加分号 */

❌ 错误 3：continue 在 for 循环中跳过了递增

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        continue;  /* continue 会跳到 i++，所以这种写法是安全的 */
    }
    printf("%d ", i);
}
/* 注意：上面的代码是正确的。但如果递增放在循环体内： */

int j = 0;
while (j < 10) {
    if (j == 5) {
        continue;  /* ❌ continue 跳过 j++，j 永远 = 5，死循环！ */
    }
    printf("%d ", j);
    j++;
}

✅ 修正：确保 continue 不会跳过后置的递增操作。

int j = 0;
while (j < 10) {
    if (j == 5) {
        j++;        /* ✅ continue 前先递增 */
        continue;
    }
    printf("%d ", j);
    j++;
}

动手练习

🟢 练习 1：计算 1 到 100 中所有偶数的和

/* 用 for 循环实现，结果应为 2550 */

int sum = 0;
for (int i = 2; i <= 100; i += 2) {
    sum += i;
}
printf("1..100 偶数之和 = %d\n", sum);  /* 2550 */

int sum = 0;
for (int i = 1; i <= 100; i++) {
    if (i % 2 != 0) {
        continue;
    }
    sum += i;
}

🟡 练习 2：用嵌套循环打印金字塔

/* 打印如下图案（5 行）：
    *
   ***
  *****
 *******
*********
*/

int rows = 5;
for (int i = 1; i <= rows; i++) {
    /* 打印空格 */
    for (int s = 0; s < rows - i; s++) {
        putchar(' ');
    }
    /* 打印星号 */
    for (int j = 0; j < 2 * i - 1; j++) {
        putchar('*');
    }
    putchar('\n');
}

🔴 练习 3：用循环实现二分查找（Binary Search）

/* 在有序数组中查找目标值，返回索引（找不到返回 -1）
   int arr[] = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
   查找 23 → 返回 5
   查找 7  → 返回 -1
*/

int binary_search(int arr[], int n, int target) {
    int left = 0;
    int right = n - 1;

    while (left <= right) {
        int mid = left + (right - left) / 2;

        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;  /* 未找到 */
}

/* 测试 */
int arr[] = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
int n = (int)(sizeof(arr) / sizeof(arr[0]));

printf("查找 23: 索引 %d\n", binary_search(arr, n, 23));  /* 5 */
printf("查找 7:  索引 %d\n", binary_search(arr, n, 7));   /* -1 */

故障排查（FAQ）

Q: for、while、do-while 可以互相替代吗？

可以，任何循环都能用另外两种改写。选择的标准是可读性——哪个最清晰地表达你的意图就用哪个。

Q: break 能跳出多层嵌套循环吗？

不能。break 只跳出最内层的循环。如果需要跳出多层，可以用 goto（争议但有实用场景）或设置标志变量：

int found = 0;
for (int i = 0; i < 10 && !found; i++) {
    for (int j = 0; j < 10; j++) {
        if (arr[i][j] == target) {
            found = 1;
            break;
        }
    }
}

Q: 循环变量在循环结束后还能用吗？

如果在 for 的初始化中声明变量（C99 起支持），它的作用域仅限于循环体：

for (int i = 0; i < 5; i++) {
    printf("%d ", i);
}
/* i 在这里已不存在，继续使用会编译错误 */

Q: while(1) 和 for(;;) 有什么区别？

没有区别。两者都编译为相同的无限循环。选择哪个取决于个人风格，我更喜欢 for (;;)，因为它更明确地表达了"无初始化、无条件、无递增"。

知识扩展（选学）

循环优化：循环展开（Loop Unrolling）

编译器会自动做循环展开，手动展开有时能提升性能：

/* 原始：每次迭代处理 1 个元素 */
for (int i = 0; i < 100; i++) {
    process(arr[i]);
}

/* 展开：每次迭代处理 4 个元素，减少循环开销 */
for (int i = 0; i < 100; i += 4) {
    process(arr[i]);
    process(arr[i+1]);
    process(arr[i+2]);
    process(arr[i+3]);
}

范围-based 循环

C 语言没有像 C++ 的 for (int x : arr) 语法，但你可以用宏模拟：

#define FOR_EACH(elem, arr, len) \
    for (size_t _i = 0; _i < (len) && ((elem) = (arr)[_i]); _i++)

int nums[] = {1, 2, 3};
int val;
FOR_EACH(val, nums, 3) {
    printf("%d\n", val);
}

GCC 的 __attribute__((hot))

给频繁执行的循环加上此属性，可以提示编译器优化：

for (int i = 0; i < 1000000; i++)
    __attribute__((hot)) process(arr[i]);

小结

恭喜！你已经掌握了 C 语言的循环结构。让我帮你回顾一下——

• for：适合已知次数的循环，三步曲：初始化 → 条件 → 递增
• while：条件驱动，可能一次都不执行
• do-while：至少执行一次，适合输入验证
• break 终止整个循环，continue 跳过本次迭代
• 嵌套循环 = 外层走一步，内层跑一圈
• 循环不变量帮助你理解并证明循环的正确性
• 无限循环必须有安全的退出机制（break）
• 选择循环类型的标准：哪个最清晰地表达意图

我的理解：循环不是"会写就行"，关键在于选择正确的类型和保证循环终止。每次写循环前，我都会问自己：初始条件是什么？终止条件是什么？每次迭代在靠近终止条件吗？

术语表

延伸阅读

• cppreference: Iteration Statements (C)
• Beej's Guide to C: Loops
• K&R《C 程序设计语言》第 1.10 节：循环
• 《C Primer Plus》第 6 章：C 控制语句：循环

继续学习

循环是 C 语言"重复执行"的基础。下一章我们将学习预处理器与宏，了解编译之前发生的事情——#define、#include、条件编译等如何在代码运行前完成魔法般的替换。

💡 提示：试着把你之前写的重复代码改成循环形式。如果你的代码里有连续 3 行相似的结构，几乎一定可以用循环简化！

← 上一章：控制流 | 下一章：预处理器与宏 →

预处理器与宏（Preprocessor & Macros）

"预处理器像是个隐形助手——你在写代码，它在帮你抄写、替换、修剪。" —— 我发现

开篇故事

想象一家印刷厂。印报纸之前，排版工人会把模板里的占位符替换成当天的新闻标题、日期和栏目内容。模板本身不是报纸，但在正式印刷之前，替换工作必须先完成。预处理器做的事情与此类似——它不编译代码，它在编译之前做文本替换。

#define BUFFER_SIZE 256 相当于在排版模板里写了一个替换规则。代码里每一处 BUFFER_SIZE 都会在真正编译之前被替换成 256。#include <stdio.h> 更直接——它等于把整个标准库头文件复制到当前文件里。这两件事都不涉及语法检查或类型安全，预处理器只负责抄写和替换，它不理解 C 语言的语义。

这种机制带来了巨大的灵活性。同一个模板可以通过 #ifdef __linux__ 在 Linux 上编译，也可以通过 #ifdef __APPLE__ 在 macOS 上编译。但它也是所有宏陷阱的根源——因为预处理器只是机械地替换文本，#define SQUARE(x) x * x 遇到 SQUARE(3+2) 会算出 11，就像排版工人机械替换了占位符，却没检查替换后的语义对不对。

预处理器是编译前的抄写员——高效但不聪明，理解这一点就能避开绝大多数坑。

本章适合谁

• 代码中满是"魔法数字"，想学会用常量的 C 初学者
• 对 #include <stdio.h> 到底做了什么感到好奇的人
• 想写跨平台代码（用 #ifdef 区分 macOS/Linux/Windows）的人
• 用过 #define 但踩过宏陷阱的人

你会学到什么

• #define 定义常量与宏函数
• #include 的工作原理（文本替换本质）
• 头文件卫士（Include Guard）机制
• #undef 取消宏定义
• 条件编译：#ifdef / #ifndef / #elif / #endif
• #error 在编译期中断并报错
• 字符串化运算符（#）：将参数转成字符串
• Token 拼接运算符（##）：连接两个标识符
• 多行宏与 do { ... } while(0) 惯用法
• 常见宏陷阱与防护措施

前置要求

• 能编译运行基本的 C 程序
• 了解函数调用与返回值
• 用过 #include <stdio.h>

第一个例子：用 #define 消除魔法数字

#include <stdio.h>

#define MAX_STUDENTS 30
#define PASS_SCORE   60

int main(void) {
    int scores[] = {85, 45, 72, 58, 91};
    int passed = 0;

    for (int i = 0; i < 5; i++) {
        if (scores[i] >= PASS_SCORE) {
            passed++;
        }
    }
    printf("通过率: %d/%d\n", passed, 5);
    return 0;
}

运行结果：

通过率: 3/5

看起来没什么特别的？但如果我想把及格线从 60 改成 70，只需改一行 #define PASS_SCORE 70——比全局搜索替换安全得多。

原理解析

1. #define 常量替换

#define 的本质就是文本替换——编译器在编译之前，预处理器会把代码中所有出现的宏名替换为定义的值。

#define PI 3.14159
#define APP_NAME "C Tutorial"

double area = PI * 5.0 * 5.0;
/* 预处理后变为: double area = 3.14159 * 5.0 * 5.0; */

printf("Hello from %s\n", APP_NAME);
/* 预处理后变为: printf("Hello from %s\n", "C Tutorial"); */

我的理解：#define 不是变量，不是常量，它就是简单的"查找替换"。预处理器不关心类型、不检查语法——它只负责替换。

2. #include 的本质

#include 做的事情非常朴素：把被包含文件的全部内容复制粘贴到这个位置。

/* 你写的代码 */
#include <stdio.h>
int main(void) { printf("hi\n"); return 0; }

/* 预处理后，stdio.h 几千行内容被插入到这里 */
/* ... stdio.h 的全部内容 ... */
int main(void) { printf("hi\n"); return 0; }

<> vs "" 的区别：

• #include <stdio.h>：从系统头文件路径查找（如 /usr/include）
• #include "my.h"：从当前文件所在目录开始查找，然后在 -I 参数指定的路径中查找

3. 头文件卫士（Include Guard）

同一个头文件被多次 #include 会导致重复定义错误。头文件卫士解决了这个问题：

/* my.h */
#ifndef MY_H          /* 如果 MY_H 未定义 */
#define MY_H          /* 定义为标记 */

void my_function(void);  /* 实际内容 */

#endif                  /* 结束 */

执行流程：

1. 第一次包含：MY_H 未定义 → 进入 → 定义 MY_H → 包含内容
2. 第二次包含：MY_H 已定义 → 跳过整个文件 → 不重复包含

我的理解：头文件卫士就像一道门——第一次经过时开门并插上门栓，第二次来时发现门已经闩上了，就不会再进来了。

4. 宏函数（Macro Functions）

宏可以像函数一样带参数：

#define MAX(a, b) (((a) > (b)) ? (a) : (b))

int x = MAX(10, 20);  /* 展开为: (((10) > (20)) ? (10) : (20)) */

括号为什么这么重要？ 因为宏只是文本替换，如果不加括号，运算符优先级会打乱你的预期：

/* 不好的写法 */
#define BAD_SQUARE(x) x * x

/* BAD_SQUARE(3+2) 展开为: 3 + 2 * 3 + 2 = 3 + 6 + 2 = 11 (预期 25!) */

/* 正确的写法 */
#define GOOD_SQUARE(x) ((x) * (x))

/* GOOD_SQUARE(3+2) 展开为: ((3+2) * (3+2)) = 25 */

5. #undef 取消宏定义

#define TEMP 42
printf("%d\n", TEMP);  /* 42 */

#undef TEMP
/* TEMP 在此之后不再可用 */

用途：避免宏名冲突，或在局部范围内临时使用某个宏。

6. 条件编译

#ifdef __APPLE__
    printf("Running on macOS\n");
#elif defined(__linux__)
    printf("Running on Linux\n");
#elif defined(_WIN32)
    printf("Running on Windows\n");
#else
    printf("Unknown platform\n");
#endif

常用场景：

• 跨平台代码适配
• 调试信息开关（#ifdef DEBUG）
• 功能模块的启用/禁用

7. #error 编译期错误

#if MAX_BUFFER < 64
    #error "MAX_BUFFER must be >= 64"
#endif

#error 会在预编译阶段立刻停止编译并输出错误信息。比运行时检查更早发现问题。

8. 字符串化（# 运算符）

# 把宏参数转换为字符串字面量：

#define STRINGIFY(x) #x

printf("%s\n", STRINGIFY(hello world));
/* 展开为: printf("%s\n", "hello world"); */

/* 实用的调试宏 */
#define PRINT_VAR(v) printf(#v " = %d\n", v)

int x = 42;
PRINT_VAR(x);
/* 展开为: printf("x" " = %d\n", x); 输出 "x = 42" */

9. Token 拼接（## 运算符）

## 把两个标识符拼接成一个：

#define CONCAT(a, b) a##b

int data1 = 100;
int data2 = 200;

printf("%d\n", CONCAT(data, 1));  /* 展开为 data1 → 100 */

10. 多行宏与 do { ... } while(0)

#define SWAP(a, b) do {       \
    int t = (a);              \
    (a) = (b);                \
    (b) = t;                  \
} while (0)

为什么用 do {...} while(0)？ 因为它能确保宏在任何上下文中都行为一致——即使在 if 语句中不带 {}：

/* 如果宏是 { ... }，这个会出问题: */
if (condition)
    SWAP(a, b);  /* 分号导致语法错误 */
else
    return;

/* 但用 do {...} while(0) 就没问题: */
if (condition)
    SWAP(a, b);  /* do {...} while(0); 是完整的语句 */
else
    return;

常见错误

❌ 错误 1：宏函数缺少括号，导致优先级问题

#define SQUARE(x) x * x

int result = SQUARE(3 + 2);
/* 展开为: 3 + 2 * 3 + 2 = 3 + 6 + 2 = 11 */
/* ❌ 期望 25，实际 11 */

✅ 修正：参数和整个表达式都加括号。

#define SQUARE(x) ((x) * (x))  /* ✅ 加上外层和内层括号 */

int result = SQUARE(3 + 2);
/* 展开为: ((3 + 2) * (3 + 2)) = 25 */

❌ 错误 2：宏头文件卫士拼写错误

/* utils.h */
#ifndef UTILS_H
#define UTILX_H      /* ❌ 拼写错误：UTILX 而不是 UTILS */

void my_func(void);

#endif

✅ 修正：#define 后的名字必须与 #ifndef 后的完全一致。

/* utils.h */
#ifndef UTILS_H
#define UTILS_H      /* ✅ 一致 */

void my_func(void);

#endif

❌ 错误 3：宏参数有副作用时被多次求值

#define MAX(a, b) (((a) > (b)) ? (a) : (b))

int v = 5;
int result = MAX(v++, 3);
/* 展开为: (((v++) > (3)) ? (v++) : (3)) */
/* v++ 被求值了两次！v 变成 7 而不是预期 6 */
/* ❌ 副作用被重复执行 */

✅ 修正：有副作用的参数不要传给宏，改用内联函数（inline）。

static inline int max_int(int a, int b) {
    return (a > b) ? a : b;
}

int v = 5;
int result = max_int(v++, 3);  /* ✅ 函数只求值一次，v 变成 6 */

动手练习

🟢 练习 1：用 #define 定义安全缓冲区大小

/* 定义 BUFFER_SIZE 为 128，用它声明一个字符数组，
   并用 snprintf 安全地写入字符串 */

#include <stdio.h>
#define BUFFER_SIZE 128

int main(void) {
    char buffer[BUFFER_SIZE];
    const char *msg = "Hello, safe buffer!";
    snprintf(buffer, BUFFER_SIZE, "%s", msg);
    printf("%s\n", buffer);
    return 0;
}

🟡 练习 2：用 #ifdef 实现调试开关

/* 定义 DEBUG_LEVEL 为 2，根据级别输出不同信息
   DEBUG_LEVEL >= 2: 打印详细调试信息
   DEBUG_LEVEL >= 1: 打印普通信息
   否则: 打印发布信息 */

#include <stdio.h>
#define DEBUG_LEVEL 2

int main(void) {
#if DEBUG_LEVEL >= 2
    printf("[DEBUG] 详细模式: x = %d, y = %d\n", 42, 100);
#endif
#if DEBUG_LEVEL >= 1
    printf("[INFO] 程序开始执行。\n");
#endif
    return 0;
}

🔴 练习 3：实现一个安全的 MAX 内联函数 + 宏

/* 实现 max_int 内联函数，并用宏 MAX_SAFE 自动选择
   类型（使用 _Generic，C11 特性）支持 int 和 double */

#include <stdio.h>

static inline int max_int(int a, int b) {
    return (a > b) ? a : b;
}

static inline double max_double(double a, double b) {
    return (a > b) ? a : b;
}

#define MAX_SAFE(a, b) _Generic((a), \
    int:    max_int,                 \
    double: max_double               \
)(a, b)

int main(void) {
    printf("%d\n", MAX_SAFE(10, 20));        /* 20 (int) */
    printf("%.2f\n", MAX_SAFE(3.14, 2.72));  /* 3.14 (double) */
    return 0;
}

故障排查（FAQ）

Q: #define 和 const 有什么区别？该用哪个？

我的建议：优先用 const（更安全、可调试），只有在需要"代码片段替换"时才用 #define。

Q: #include "xxx.h" 找不到文件怎么办？用 -I 参数指定搜索路径。

gcc -I/path/to/headers main.c -o main

Q: 怎么查看预处理后的代码？

gcc -E main.c       # 输出到终端
gcc -E main.c -o main.i  # 输出到文件

Q: #define 可以定义带多个参数的宏吗？

可以。参数用逗号分隔：

#define PRINT_TWO(a, b) printf("%s %s\n", a, b)
PRINT_TWO("hello", "world");

知识扩展（选学）

C11 _Static_assert

编译期断言，比 #error 更灵活：

#include <stdio.h>

#define BUFFER_SIZE 32
_Static_assert(BUFFER_SIZE >= 64, "BUFFER_SIZE must be >= 64");

int main(void) { return 0; }
/* 编译错误: static assertion failed: "BUFFER_SIZE must be >= 64" */

GCC 扩展：#warning

与 #error 类似，但只发出警告而不终止编译：

#if DEBUG_MODE
    #warning "Debug mode is enabled — don't ship like this!"
#endif

X-Macro 模式

一种高级宏技巧，用于生成重复代码（比如把枚举和字符串保持同步）：

#define COLORS \
    X(RED, 0)    \
    X(GREEN, 1)  \
    X(BLUE, 2)

#define X(name, value) name = value,
enum Color { COLORS };
#undef X

#define X(name, value) [name] = #name,
const char *color_names[] = { COLORS };
#undef X

小结

祝贺！你已经掌握了 C 预处理器的核心机制。让我总结一下——

• #define 是文本替换，不是变量、不是函数
• #include 本质是复制粘贴，<> 查系统路径、"" 查当前路径
• 头文件卫士（#ifndef/#define/#endif）防止重复包含
• 宏函数必须给参数和整体都加括号，否则优先级会出错
• # 字符串化，## token 拼接
• 多行宏用 do {...} while(0) 确保行为正确
• 有副作用的参数不要传给宏——用内联函数替代
• #error 在编译期捕获配置错误

我的理解：预处理器的核心原则就是记住——它发生在编译之前，做的是纯文本操作。理解这一点，90% 的宏陷阱都可以避免。

术语表

延伸阅读

• cppreference: Preprocessor Directives (C)
• GCC Preprocessor Options
• K&R《C 程序设计语言》第 4 章：宏
• 《C Primer Plus》第 16 章：C 预处理器和 C 库

继续学习

预处理器是 C 语言"元编程"的基础。下一章我们将学习数组，掌握 C 语言中最基本的集合数据结构——从一维数组到多维数组，从内存布局到指针运算。

💡 提示：检查你现有代码中的所有"魔法数字"，用 #define 或 const 替换它们。你会发现代码可读性立刻提升了！

← 上一章：循环 | 下一章：数组 →

指针基础 (Pointer Basics)

开篇故事

想象你拿到一张酒店房卡。房卡上印的不是房间本身，而是一个房间号。你需要拿着这个号码走到对应的门前，刷卡，才能进入房间。

指针就是 C 语言里的「房卡」。它不存储数据本身，而是存储数据所在的地址。&a 是在问「a 住在哪个地址」，*p 是拿着地址 p 走到门前，开门看看里面是什么。

int a = 10;
int *p = &a;   // p 拿着 a 的地址，像房卡指向房门
*p = 20;       // 顺着地址找到 a，修改门里的值

很多人第一次看到 * 和 & 就觉得玄乎。其实它们做的事情很朴素：一个告诉你「去哪找」，一个帮你「找到以后打开看」。理解了这一点，指针就不再是神秘的咒语，而是 C 语言给你的一把手术刀——锋利，但握对了就不怕受伤。

"指针的本质不是数据，而是数据的地址。" —— 每一个 C 程序员迟早会明白的事

本章适合谁

• 已经掌握 C 语言变量和数据类型基础
• 听说过「指针」但总觉得神秘、怕踩坑
• 用过 Python/JavaScript 等高级语言，想了解 C 的内存控制能力
• 被「段错误 (Segmentation Fault)」折磨过的初学者

你会学到什么

1. 指针的声明方法：int *p 到底是什么意思
2. & 取地址运算符和 * 解引用运算符的用法
3. 如何在内存中用指针「定位」和「修改」数据
4. NULL 指针的含义及安全检查模式
5. 指针类型（int* vs char*）对解范围的影响
6. 如何正确初始化指针，避免野指针

前置要求

已完成 变量 和 数据类型 章节。你需要理解：

• 变量是内存中的命名存储空间
• 不同类型（int、double、char）占据不同大小的内存
• <stdint.h> 中的固定宽度类型（int32_t、int64_t 等）

第一个例子

下面是最简短的指针演示程序。它声明一个变量和一个指向它的指针，然后打印它们的值和地址：

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

int main(void) {
    int32_t  num = 42;     /* 普通变量 */
    int32_t *ptr = &num;   /* 指针：存储 num 的地址 */

    printf("num 的值  = %d\n", num);
    printf("num 的地址 = %p\n", (void *)&num);
    printf("ptr 的值  = %p  (和 num 的地址相同)\n", (void *)ptr);
    printf("*ptr 的值 = %d  (解引用得到 num 的值)\n", *ptr);

    *ptr = 100;            /* 通过指针修改 num */
    printf("修改 *ptr = 100 后, num = %d\n", num);

    return 0;
}

编译并运行：

gcc -Wall -Wextra -std=c17 -o demo demo.c
./demo

输出：

num 的值  = 42
num 的地址 = 0x7ffee4c4a3ac
ptr 的值  = 0x7ffee4c4a3ac  (和 num 的地址相同)
*ptr 的值 = 42  (解引用得到 num 的值)
修改 *ptr = 100 后, num = 100

这段代码做了几件事：

• 声明了一个 int32_t 变量 num，值为 42
• 声明了一个指针 ptr，用 &num 把 num 的地址赋给它
• *ptr 解引用——顺着地址找到 num，读取它的值
• 通过 *ptr = 100 修改指针指向的内容，等价于修改 num 本身

原理解析

指针语法：& 取地址 和 * 解引用

C 语言中有两个专门的指针运算符：

int32_t num = 42;
int32_t *ptr = #

/* num 是变量名, 值是 42 */
/* ptr 是指针, 值是 &num (num 的地址) */
/* *ptr 是解引用, 等价于 num */

printf("%d\n", num);   /* 42 */
printf("%d\n", *ptr);  /* 42, 通过指针读 */
*ptr = 99;
printf("%d\n", num);   /* 99, num 被改变了! */

内存布局：ASCII 示意图

理解指针最直观的方法是看内存图。假设变量 x 和指针 px 都在栈上：

  符号        地址           值
  ------+---------------+--------------
  x     | 0x7ff...b0    |  42
  px    | 0x7ff...b8    |  0x7ff...b0  ← px 里存的是 x 的地址
                                  ↑
                           *px → 0x7ff...b0 → 42

• x 在地址 0x7ff...b0 处，存放数值 42
• px 在地址 0x7ff...b8 处，存放的是 0x7ff...b0（即 &x）
• *px 的意思是：取出 px 中的值 (0x7ff...b0)，然后到那个地址取值，得到 42

NULL 指针

NULL 是一个特殊地址值（通常是 0），表示「不指向任何有效数据」。

永远不要解引用 NULL 指针——会导致段错误 (Segmentation Fault)：

int32_t *ptr = NULL;
printf("%d\n", *ptr);  /* ❌ Segmentation fault! 程序崩溃 */

正确做法是使用前检查：

int32_t *ptr = NULL;
/* ... 某个函数可能给 ptr 赋值 ... */
if (ptr != NULL) {
    printf("%d\n", *ptr);  /* ✅ 安全 */
} else {
    printf("ptr is NULL\n");
}

指针初始化

野指针 (Dangling Pointer) 是最常见的指针错误之一——声明了指针但没有初始化，它指向一个随机内存地址。

int32_t *p;   /* ❌ 未初始化! p 指向随机地址 */
*p = 42;      /* ❌ 向随机地址写入 = 崩溃 或 数据损坏 */

两种安全的初始化方式：

int32_t val = 42;
int32_t *p1 = &val;  /* ✅ 指向有效变量 */
int32_t *p2 = NULL;  /* ✅ 明确指向空 */

指针类型

指针的类型决定了编译器如何解释它指向的内存：

int32_t  num = 0x01020304;
int32_t *pi = #   /* pi 每次移动 4 字节 */
uint8_t *pb = (uint8_t *)#  /* pb 每次移动 1 字节 */

printf("%d\n", *pi);  /* 读取整个 int32_t (4 字节) */
printf("%d\n", *pb);  /* 只读取第一个字节 */

指针类型的重要性：

• int32_t*：解引用时读取 4 字节，指针加法 p+1 前进 4 字节
• uint8_t*：解引用时读取 1 字节，指针加法 p+1 前进 1 字节
• 类型不匹配时，编译器会给出警告

常见错误

错误 1：解引用野指针

/* ❌ 错误代码 */
int32_t *p;      /* 未初始化 */
*p = 42;         /* 写入随机内存地址 */

编译器可能不会报错（或未初始化警告），但运行时会段错误或产生难以调试的数据损坏：

Segmentation fault (core dumped)

/* ✅ 修复：初始化指针 */
int32_t  val = 0;
int32_t *p = &val;   /* 指向有效变量 */
*p = 42;              /* 安全 */

错误 2：解引用 NULL 指针

/* ❌ 错误代码 */
int32_t *p = NULL;
printf("%d\n", *p);   /* 解引用 NULL = 崩溃 */

运行时报错：

Segmentation fault (core dumped)

/* ✅ 修复：检查 NULL */
int32_t *p = NULL;
int32_t target = 42;
p = ⌖
if (p != NULL) {
    printf("%d\n", *p);   /* 安全检查后使用 */
}

错误 3：混淆 *p = value 与 p = &value

/* ❌ 错误代码 */
int32_t a = 10;
int32_t b = 20;
int32_t *p = &a;
p = &b;   /* 这个操作是"让 p 改指向 b"，不是"修改 a 为 20" */
printf("%d\n", *p);  /* 输出 20 */
printf("%d\n", a);   /* a 还是 10! 没被修改 */

/* ✅ 如果你想通过指针修改 a 的值 */
int32_t *p = &a;
*p = 20;   /* *p 解引用 = a，现在 a = 20 */
printf("%d\n", a);   /* 输出 20 */

动手练习

🟢 入门：交换两个变量

声明 int32_t a = 3 和 int32_t b = 7，用指针修改它们的值，使得 a 变成 7、b 变成 3。

int32_t a = 3, b = 7;
int32_t *pa = &a;
int32_t *pb = &b;

int32_t temp = *pa;
*pa = *pb;
*pb = temp;

printf("a = %d, b = %d\n", (int)a, (int)b);
/* 输出: a = 7, b = 3 */

🟡 中级：指针遍历

声明一个 int32_t 数组 {10, 20, 30, 40, 50}，用指针（不是数组索引 []）遍历并打印所有元素。

int32_t arr[] = {10, 20, 30, 40, 50};
int32_t n = (int32_t)(sizeof(arr) / sizeof(arr[0]));
int32_t *p = arr;  /* 数组名 = 首元素地址 */

for (int32_t i = 0; i < n; i++) {
    printf("%d ", *(p + i));  /* *(p + i) 等价于 p[i] 等价于 arr[i] */
}
printf("\n");
/* 输出: 10 20 30 40 50 */

🔴 挑战：NULL 防御

写一个函数 safe_divide(int32_t a, int32_t b, int32_t *result)，当 b == 0 时返回失败（result 保持 NULL 不解引用），否则执行 *result = a / b。调用方必须在使用 result 前检查是否为 NULL。

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

int safe_divide(int32_t a, int32_t b, int32_t *result)
{
    if (b == 0) {
        return 0;  /* 除数不能为 0 */
    }
    if (result != NULL) {
        *result = a / b;
    }
    return 1;  /* 成功 */
}

int main(void)
{
    int32_t res = 0;
    if (safe_divide(10, 3, &res)) {
        printf("10 / 3 = %d\n", (int)res);  /* 输出: 3 */
    }
    if (!safe_divide(10, 0, &res)) {
        /* 除零失败, res 保持原值 */
        printf("除零错误, res = %d (未修改)\n", (int)res);
    }
    return 0;
}

故障排查 (FAQ)

Q：* 在声明里和在使用里含义不一样？

A：对！这是 C 语言最容易混淆的地方之一：

• int *p; 声明：* 表示 p 是一个「指向 int 的指针」类型
• *p = 10; 使用：* 是解引用运算符，「找到 p 指向的那个变量，赋值 10」
• 一个是类型标记，一个是运行时操作。

Q：什么是指针的「类型」？为什么不能所有指针都用 void*？

A：指针类型告诉编译器两个重要信息：

1. 解引用范围：int32_t* 解引用读 4 字节，char* 读 1 字节
2. 指针算术步长：p+1 在 int32_t* 里前进 4 字节，在 char* 里前进 1 字节

void*（无类型指针）确实存在，但你不能直接 *vp 解引用——必须先转换为具体类型。

Q：int *p 的 * 应该贴紧谁？int *p 还是 int* p？

A：两种风格都可以，但要注意：* 属于变量名，不是类型名。

int* a, b;   /* a 是 int*, b 是 int —— 不是两个指针！ */
int *a, *b;  /* 这才是两个 int* */

很多 C 程序员偏好 int *p（星号贴变量）来提醒自己 * 是变量修饰符。

Q：指针和索引 [] 有什么关系？

A：arr[i] 在 C 语言中本质上就是 *(arr + i) 的语法糖！

int32_t arr[3] = {10, 20, 30};
/* 以下两种写法完全等价 */
printf("%d\n", arr[1]);    /* 20 */
printf("%d\n", *(arr + 1)); /* 20 */

知识扩展 (选学)

指向指针的指针 (Pointer to Pointer)

指针本身也是变量，也有地址。所以你可以声明一个指针指向另一个指针：

int32_t  value = 42;
int32_t *ptr = &value;      /* ptr → value */
int32_t **pptr = &ptr;       /* pptr → ptr → value */

printf("%d\n", value);      /* 42 */
printf("%d\n", *ptr);       /* 42 */
printf("%d\n", **pptr);     /* 42 (两次解引用) */

这在以下场景非常有用：

• 函数内修改指针本身（不是修改指针指向的值，而是修改指针的指向）
• 动态二维数组（char** argv 就是命令行参数数组）
• 链表头节点的修改

/* 函数内修改指针指向的例子 */
void set_to_null(int32_t **pp)
{
    *pp = NULL;   /* 修改 pp 自身，不是它指向的值 */
}

int32_t *p = &some_value;
set_to_null(&p);  /* 现在 p 变成 NULL 了 */

Python 变量 vs C 指针对比表

小结

本章的核心要点：

• 指针是存储内存地址的变量，类型为 T*（T 是指向的类型）
• & 取地址运算符，&var 返回变量的地址
• * 解引用运算符，*ptr 访问指针指向的值
• NULL 指针表示不指向任何数据，使用前必须检查
• 野指针（未初始化的指针）是危险的——始终初始化为有效地址或 NULL
• 指针类型决定了解引用范围和指针算术步长
• arr[i] 本质上是 *(arr + i) 的语法糖

术语表

延伸阅读

• C17 标准 §6.5.3.2 — 解引用运算符 — 官方标准中的指针定义
• cppreference - Pointers — 指针类型和操作的完整参考
• Kernighan & Ritchie《The C Programming Language》§5.1-5.5 — 经典指针章节

选择建议：初学者建议先阅读 cppreference 的指针章节理解基本概念；有一定基础后再看 K&R 经典教材的指针章节加深理解。

继续学习

本章你已经理解了 C 语言最核心的概念——指针。它是 C 语言强大但也容易出错的原因。下一步，我们将学习指针算术——如何用指针遍历数组、实现字符串操作、以及指针与数组的等价关系。

• 上一章：数据类型
• 下一章：指针算术

指针运算 (Pointer Arithmetic)

在上一章，我知道了指针就像一个"遥控器"——它存储了内存地址，通过 * 可以读/写那个地址上的值。但指针真正强大的地方还在于：它可以移动。

int32_t arr[5] = {1, 2, 3, 4, 5};
int32_t *p = arr;   // p 指向 arr[0]
p++;                // p 现在指向 arr[1]！
*p;                 // 值是 2

这种能力称为指针算术 (Pointer Arithmetic)——它是 C 语言高效操作的秘密武器，也是初学者的头号陷阱。

开篇故事

想象你走进一条走廊，两边是一扇扇编号连续的门。你站在第一扇门前，往前走一步就到了第二扇门，再走一步是第三扇。每一步的大小取决于门本身的宽度——窄门一步就跨过去，宽门需要多花一点力气。

指针算术就是在这条走廊里「走路」。指针加 1 不是地址加 1，而是移动「一个元素」的距离。int32_t* 走一步跳过 4 字节，int64_t* 走一步跳过 8 字节。步长由类型决定。

int32_t arr[4] = {10, 20, 30, 40};
int32_t *p = arr;    // 站在第一扇门前 (arr[0])
p++;                 // 往前走一步，现在站在 arr[1] 门前
*p;                  // 打开门一看，值是 20

指针算术的危险之处在于：走廊走到尽头之后还有空间，但那已经不属于这排房间了。越过数组边界继续走，你读到的就不再是有效数据，而是走廊尽头的杂物间——编译器不会阻止你，后果自己承担。

"越界的指针不会报错，只会给你一段随机内存。这也是 C 语言的信任哲学。"

本章适合谁

• 已经了解指针基础（& 取地址、* 解引用）
• 刚学完数组，好奇"数组名是不是指针"
• 被段错误（Segmentation Fault）折磨过的程序员
• 想知道 C 为什么比 Python 快的底层原因

你会学到什么

• 指针的 ++、--、+n、-n 运算及其步长规则
• 数组与指针的等价性：arr[i] ≡ *(arr + i)
• sizeof 在数组和指针上的区别（最易踩坑）
• 指针相减：计算两个元素之间的距离
• 指针比较：>、<、==、!= 的含义
• 常见陷阱：越界指针、无符号字节指针

前置要求

完成 指针基础 (Pointers) 和 数组 (Arrays) 章节。

第一个例子

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

int main(void) {
    int32_t nums[5] = {10, 20, 30, 40, 50};
    int32_t *p = nums;  // p 指向 nums[0]

    printf("%d\n", *p);     // 10
    p++;                    // p 前移 1 个 int32_t
    printf("%d\n", *p);     // 20
    p = p + 2;              // p 再前移 2 个 int32_t
    printf("%d\n", *p);     // 50
    return 0;
}

输出：

10
20
50

分步解析

1. int32_t *p = nums：nums 是数组名，代表数组首地址，赋值给指针 p
2. *p：解引用，得到 nums[0] 的值（10）
3. p++：指针自增，移动 sizeof(int32_t) = 4 字节，指向 nums[1]
4. p = p + 2：指针加 2，再前进 2 个 int32_t 位置（8 字节），指向 nums[3]

原理解析

指针加 1，究竟移动多少？

这是指针算术最核心的规则：指针 +1 不是地址 +1，而是移动一个「元素」的距离。

假设 int32_t* p 起始地址 = 0x1000

     操作      地址变化              指向
   ────────────────────────────────────────────
     p         0x1000         →  nums[0]
     p+1       0x1000 + 4     →  nums[1]  (移动 4 字节)
     p+2       0x1000 + 8     →  nums[2]
     p+n       0x1000 + n×4   →  nums[n]

移动的距离 = 元素的 sizeof。

💡 编译器在编译时自动根据指针类型计算偏移量，你不需要手动算。

数组与指针的等价性

C 语言中，数组访问在底层就是指针算术：

int32_t a[4] = {7, 14, 21, 28};

a[2]      // ≡  *(a + 2)     完全等价！
&a[1]     // ≡   a + 1        地址相同！

内存布局 (每个元素 4 字节):
┌──────┬──────┬──────┬──────┐
│  07  │  0E  │  15  │  1C  │  ← 十六进制值
└──────┴──────┴──────┴──────┘
  ↑        ↑        ↑        ↑
a+0      a+1      a+2      a+3
&a[0]    &a[1]    &a[2]    &a[3]

这意味着：用 a[i] 编写的代码，编译器内部会翻译为 *(a + i)。

sizeof：数组 vs 指针

这是我学到指针时最容易混淆的地方。sizeof 作用于数组名和指针，结果完全不同：

int32_t arr[8] = {0};
int32_t *ptr = arr;

sizeof(arr)     // = 32  (8 个元素 × 4 字节)
sizeof(ptr)     // = 8   (指针本身的大小)

sizeof(arr[0])  // = 4   (单个 int32_t)
sizeof(*ptr)    // = 4   (解引用后是单个元素)

// 计算元素个数：只对数组有效
sizeof(arr) / sizeof(arr[0])  // = 32 / 4 = 8 ✓
sizeof(ptr) / sizeof(*ptr)    // = 8 / 4 = 2 ✗ （错误！）

关键规则：一旦数组被赋值给指针变量（或作为函数参数传递），sizeof 就再也无法知道数组的实际大小。

指针相减：计算距离

两个同类型指针相减，得到它们之间的元素个数（不是字节数）：

int32_t nums[6] = {10, 20, 30, 40, 50, 60};
int32_t *start = &nums[0];
int32_t *end   = &nums[5];

ptrdiff_t dist = end - start;  // dist = 5（元素数）
                               // 字节数 = 5 × 4 = 20

结果类型是 ptrdiff_t（定义在 <stddef.h>），它是一个有符号整数，保证能表示任何合法指针差值。

指针比较

同一数组内的指针可以比较大小：

int32_t vals[5] = {50, 40, 30, 20, 10};
int32_t *p1 = &vals[0];
int32_t *p2 = &vals[4];

p1 < p2   // true，p1 在内存中更"靠前"
p1 == p2  // false
p1 == p2  // false（不同的元素地址不同）

比较指针大小等价于比较它们指向的元素在数组中的位置。p1 < p2 意味着 p1 指向的元素比 p2 更早出现在数组中。

常见错误

❌ 错误 1：指针越界——最危险的陷阱

int32_t arr[4] = {10, 20, 30, 40};
int32_t *p = arr;

p = p + 4;   // p 已经越过了整个数组
*p = 999;    // ❌ 向未知内存写入！可能崩溃，可能 corrupt 数据

修复：始终用 < 控制指针范围：

int32_t *p = arr;
int32_t *end = arr + 4;

for (; p < end; p++) {
    printf("%d ", *p);  // 安全遍历
}

注意：p = arr + 4（指向最后一个元素之后）是合法的，但不能解引用它。p = arr + 5 则是未定义行为。

❌ 错误 2：用 sizeof 获取指针指向的数组长度

int32_t *ptr = arr;
size_t count = sizeof(ptr) / sizeof(*ptr);  // ✗ 得到 1 或 2，不是 8！

修复——在调用处计算好再传指针：

void process(int32_t *data, size_t count) {
    // count 由调用者传入
    for (size_t i = 0; i < count; i++) {
        printf("%d\n", data[i]);
    }
}

int main(void) {
    int32_t arr[8] = {0};
    process(arr, sizeof(arr) / sizeof(arr[0]));
}

❌ 错误 3：比较不同数组的指针

int32_t a[5];
int32_t b[5];
int32_t *p1 = a;
int32_t *p2 = b;

if (p1 < p2) { }  // ❌ 未定义行为！不同数组之间的地址比较无意义

修复：只比较同一数组内的指针。

动手练习

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

int main(void) {
    int32_t arr[5] = {1, 2, 3, 4, 5};
    int32_t *p = arr;

    for (int32_t i = 0; i < 5; i++) {
        printf("%d ", *(p + i));
    }
    printf("\n");
    return 0;
}

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

int main(void) {
    int32_t data[7] = {10, 20, 30, 40, 50, 60, 70};
    int32_t *head = &data[0];
    int32_t *tail = &data[6];

    ptrdiff_t count = tail - head;
    printf("距离 = %td 个元素\n", count);
    return 0;
}

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

int32_t *binary_search(int32_t *first, int32_t *last, int32_t target) {
    while (first <= last) {
        int32_t *mid = first + (last - first) / 2;
        if (*mid == target) return mid;
        else if (*mid < target) first = mid + 1;
        else last = mid - 1;
    }
    return NULL;  // 未找到
}

int main(void) {
    int32_t arr[7] = {2, 5, 8, 12, 16, 23, 38};
    int32_t n = 7;
    int32_t *found = binary_search(arr, arr + n - 1, 16);
    if (found) {
        printf("找到! 索引 = %td\n", found - arr);
    }
    return 0;
}

故障排查 (FAQ)

int32_t arr[5] = {0};
int32_t *p = arr;

arr = p;     // ❌ 编译错误：数组名不能赋值
p = arr + 2; // ✅ 指针可以重新赋值

知识扩展 (选学)

指针 vs 索引：谁更快？

// 索引方式
for (int i = 0; i < n; i++) sum += arr[i];

// 指针方式
for (int32_t *p = arr; p < end; p++) sum += *p;

现代编译器（GCC/Clang）优化后两种方式生成的汇编通常是完全相同的。指针写法的"更快"优势在 20 年前可能成立，现在更多是风格偏好。

void* 指针：无类型的指针

int32_t x = 42;
void *vp = &x;  // 可以指向任何类型
int32_t *ip = vp;  // 需要显式转回去
int val = *ip;  // 解引用必须转回具体类型

void* 不能直接 *vp 或 vp++（因为不知道元素大小），必须先转换为具体类型指针。

小结

这一章我发现：

• 指针 +1 移动的是一个元素的大小，不是 1 字节——由指针类型决定
• arr[i] 和 *(arr + i) 在编译器层面完全等价
• sizeof 在数组上得到总大小，在指针上只得到指针本身的大小——最易混淆
• 指针相减得到元素个数，不是字节数（用 ptrdiff_t 类型接收）
• 只有同一数组内的指针才能比较大小
• 越界指针不报错，自己负责边界

术语表

延伸阅读

• cppreference - Pointer arithmetic — 标准指针运算规则
• ptrdiff_t / size_t —— <stddef.h> 中的标准类型
• 下一章：函数与指针 —— 指针作为函数参数、回调函数

继续学习

字符串深度 (Strings Deep Dive)

开篇故事

想象你在读一本书，但书页上没有页码，也没有目录。你怎么知道这本书什么时候结束？答案很简单——作者在最后一页写了一个特殊符号，比如一个句号，或者一张空白书签。看到它，你就知道：故事到此为止。

C 语言的字符串就是这样工作的。它没有内置的"长度"字段，没有对象包装，就是一块连续的 char 内存——用 \0（null 终止符）标记结尾。strlen 的工作就是从第一个字符开始读，一路读到 \0 停手。少了这个标记，字符串就会一直读下去，直到偶然撞见一个 0 字节，读出一堆毫不相关的随机数据。

char greeting[] = "Hello, C!";
// 编译器自动在末尾加上 '\0'：
// ['H','e','l','l','o',',',' ','C','!','\0']
//                          ↑ 故事到此为止

这就是为什么在 C 语言里处理字符串从来不是一件理所当然的事。每一步都要自己管：空间够不够？\0 有没有写？边界有没有守住。Python 替你做好的事，C 选择交给你——多一分控制，也多一分责任。

"字符串不是对象，而是一块需要你亲自收尾的内存。" —— C 语言的第一堂安全课

本章适合谁

• 刚学完"数据类型"和"数组"，想知道字符串在 C 中到底是什么
• 用过 Python/JavaScript 的 str，对 C 的 char* 感到困惑
• 听说过"缓冲区溢出"但不清楚具体原因
• 希望写出安全的字符串处理代码，而不是只会 strcpy 然后祈祷

你会学到什么

1. C 字符串的本质：null-terminated char 数组，\0 终止符的作用
2. ASCII 内存图：字符串在栈内存中如何存储，\0 的位置
3. Python str vs C char*：Python 自动管理内存，C 需要手动 null 终止
4. <string.h> 核心函数：strlen、strcpy、strncpy、strcmp、strchr、strstr、strtok
5. 安全核心：strcpy vs strncpy 的安全差异（缓冲区溢出演示 + 修复）
6. 安全核心：sprintf vs snprintf（格式化安全）
7. strlen 手动实现 vs 标准库实现
8. strtok 字符串分隔（修改原字符串的注意事项）
9. 实战：安全解析 CSV 格式字符串

前置要求

• 已完成 数据类型 章节
• 理解 char 类型（一个字节，可存储 ASCII 字符）
• 理解数组基础（int arr[10] 的声明和访问）
• 已配置 C 编译环境（gcc 或 clang）

💡 编译命令：本章代码使用 -Wall -Wextra -Werror -std=c17 编译，所有警告视为错误。

第一个例子

最简短的 C 字符串示例——看看 char[] 和 strlen 的工作方式：

#include <stdio.h>
#include <string.h>

int main(void) {
    char greeting[] = "Hello, C!";  /* 自动推导长度为 10（含 '\0'） */

    printf("内容: %s\n", greeting);
    printf("长度: %zu\n", strlen(greeting));    /* 7 (不含 \0) */
    printf("大小: %zu 字节\n", sizeof(greeting)); /* 10 (含 \0) */

    return 0;
}

编译并运行：

gcc -Wall -Wextra -Werror -std=c17 -o demo demo.c
./demo

完整源码在仓库 src/basic/strings_sample.c。

原理解析

1. C 字符串是什么？

C 语言没有内置的"字符串类型"。C 字符串本质上是一个 char 类型的数组，以 null 终止符 \0 结尾。

char greeting[] = "Hello, C!";

编译器会在背后做两件事：

1. 为 "Hello, C!" 分配 10 个字节的内存（9 个字符 + 1 个 \0）
2. 逐字节填充内容

ASCII 内存图：

  ┌── char greeting[10] = "Hello, C!" in Stack ──┐
  │                                               │
  │  Address  +0  +1  +2  +3  +4  +5  +6  +7  +8 +9│
  │          ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
  │  →      │'H'│'e'│'l'│'l'│'o'│','│' '│'C'│'!'│'\0'│
  │          │ 72│101│108│108│111│ 44│ 32│ 67│ 33│  0│
  │          └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
  │                                               │
  │  strlen(greeting) = 9 (从开始数，到 '\0' 前)   │
  │  sizeof(greeting) = 10 (整个数组大小)           │
  └───────────────────────────────────────────────┘

关键规则：

• \0（ASCII 值 0）必须存在，否则 "Hello, C!" 的结尾在哪里？没有 \0，printf("%s") 会一直读下去，直到偶然遇到一个 0 字节——缓冲区溢出读取。
• strlen() 返回 \0 前面的字符数（不包含 \0）
• sizeof 返回数组的总字节数（包含 \0）

2. Python str vs C char*

# Python — 自动管理一切
s = "Hello"
print(len(s))   # O(1)，直接读长度字段
s[0] = 'h'      # ❌ TypeError: 字符串不可变

// C — 你自己管理一切
char s[] = "Hello";
printf("%zu\n", strlen(s));  // O(n)，逐个字节查找 \0
s[0] = 'h';                  // ✅ 可以修改（char[] 不是字面量）

我的理解：C 的字符串设计哲学是"不提供任何保护，但给你完全的控制权"。这既是 C 的强大之处（极致性能），也是它的危险之处（缓冲区溢出).

3. char[] vs char* 初始化

/* char[]: 在栈上分配完整数组，内容可修改 */
char greeting[] = "Hello";
greeting[0] = 'h';  // ✅ OK

/* char*: 指向只读字符串字面量（通常放在 .rodata 段），不可修改 */
const char *literal = "Hello";
literal[0] = 'h';   // ❌ Segmentation Fault! 字面量只读

经验法则：需要修改内容 → char[]；只读引用 → const char*。

4. strcpy vs strncpy — 安全 vs 不安全

⚠️ 本章核心安全规则：在任何实际项目中，strcpy 都不应该出现在工作代码中。它没有边界检查，永远存在缓冲区溢出风险。

/* ❌ 危险：strcpy — 无边界检查 */
char small[5];
strcpy(small, "Hello World!");
/* "Hello World!" 有 13 字节（含 '\0'），small 只有 5 字节。
   结果：写入超出 small 边界，覆盖栈上的相邻变量和返回地址 →
   → Undefined Behavior → 崩溃、数据损坏、安全漏洞。 */

/* ✅ 安全：strncpy — 指定最大写入字节数 */
char small[5];
strncpy(small, "Hello World!", sizeof(small) - 1);
small[sizeof(small) - 1] = '\0';
/* 最多写入 4 个字符 + 手动设 '\0' → small = "Hell" */

strncpy 的三个参数：目标缓冲区、源字符串、最大写入字节数。

重要陷阱：如果源字符串长度 >= n，strncpy 不会自动添加 \0。所以必须手动保证 null 终止：

strncpy(dest, src, sizeof(dest) - 1);
dest[sizeof(dest) - 1] = '\0';  /* 始终保证 null termination */

5. snprintf vs sprintf

/* ❌ 危险：sprintf — 无边界检查 */
char buf[5];
sprintf(buf, "Hello, %s!", "World");
/* "Hello, World!" 共 13 字节，buf 只有 5 → 缓冲区溢出 */

/* ✅ 安全：snprintf — 指定缓冲区大小 */
char buf[5];
int ret = snprintf(buf, sizeof(buf), "Hello, %s!", "World");
/* buf = "Hell" (截断), ret = 13 (完整输出需要 13 个字符) */

snprintf 的返回值非常有用：它告诉你"如果缓冲区足够大，完整输出需要多少个字符"。如果返回值 >= 缓冲区大小，说明发生了截断。

6. strlen — 长度测量

#include <string.h>

size_t len = strlen("Hello");  // 返回 5
size_t emp = strlen("");       // 返回 0 (只有 '\0')

手动实现很简单——逐个字节查找 \0：

size_t my_strlen(const char *str) {
    size_t len = 0;
    while (str[len] != '\0') {
        len++;
    }
    return len;
}

注意：strlen() 返回的是字节数，不是字符数。UTF-8 多字节字符（如 🌍）会被计为多个字节（4 个字节）。如果需要Unicode字符计数，需要专门的 Unicode 库。

7. strcmp — 字符串比较

int result = strcmp("abc", "abcd");
// result = 负数 ("abc" < "abcd")

result = strcmp("hello", "hello");
// result = 0 (完全相同)

result = strcmp("world", "hello");
// result = 正数 ("world" > "hello")

关键：永远不要用 == 比较 C 字符串！

char *a = "hello", *b = "hello";
if (a == b)  // ❌ 比较指针地址，不是字符串内容！

8. strtok — 分隔字符串

strtok 用于将一个字符串按分隔符拆分成多个"令牌"（token）。

char text[] = "apple,banana,cherry";  /* 注意：必须是 char[]，不是 char* */
char *token = strtok(text, ",");
while (token != NULL) {
    printf("  [%s]\n", token);
    token = strtok(NULL, ",");  /* 后续调用传入 NULL */
}
// 输出: [apple]  [banana]  [cherry]

⚠️ 重要注意事项：

1. strtok 修改原字符串——它在分隔符位置写入 \0。如果原字符串是字面量（char*）或需要保留，必须先复制一份。
2. strtok 不是线程安全的——它内部使用静态变量保存状态。多线程环境使用 strtok_r（POSIX）。
3. 第一次调用传入字符串，后续调用传入 NULL。

常见错误

❌ 错误 1：缓冲区太小

/* ❌ 错误代码 */
char buf[5];
strcpy(buf, "Hello");   /* "Hello" 需要 6 字节（含 '\0'）*/

/* ✅ 修复 */
char buf[6];            /* 至少 6 字节 */
strncpy(buf, "Hello", sizeof(buf) - 1);
buf[sizeof(buf) - 1] = '\0';

❌ 错误 2：忘记 null terminator

/* ❌ 错误代码 */
char buf[5];
strncpy(buf, "ABCD", 5);   /* strncpy 写满 5 字节，没有空间放 '\0' */
printf("%s\n", buf);       /* 越界读取，输出随机数据 */

/* ✅ 修复 */
char buf[5];
strncpy(buf, "ABCD", sizeof(buf) - 1);
buf[sizeof(buf) - 1] = '\0';  /* 手动终止 */

❌ 错误 3：用 == 比较字符串

/* ❌ 错误代码 */
char a[] = "hello", b[] = "hello";
if (a == b) { /* 永远 false，比较的是指针地址 */ }

/* ✅ 修复 */
if (strcmp(a, b) == 0) { /* 比较内容 */ }

❌ 错误 4：修改字符串字面量

/* ❌ 错误代码 */
char *s = "hello";
s[0] = 'H';   /* Segmentation Fault! 只读内存 */

/* ✅ 修复 */
char s[] = "hello";  /* char[] 在栈上分配，可修改 */
s[0] = 'H';

动手练习

🟢 入门：strlen 实践

编写代码，计算字符串 "Hello, C Programming!" 的长度。不要使用 strlen()——手动实现一个 count_chars 函数，遍历字符串直到找到 \0。

#include <stdio.h>

size_t count_chars(const char *str) {
    size_t count = 0;
    while (str[count] != '\0') {
        count++;
    }
    return count;
}

int main(void) {
    const char *text = "Hello, C Programming!";
    printf("长度: %zu\n", count_chars(text));
    return 0;
}

🟡 中级：strncpy 安全复制函数

写一个函数 void safe_copy(char *dest, size_t dest_size, const char *src)，使用 strncpy 安全地将 src 复制到 dest。确保：

1. 永远不会写入超过 dest_size 字节
2. 始终保证 dest 以 \0 终止
3. 如果发生截断，打印警告信息

#include <stdio.h>
#include <string.h>

void safe_copy(char *dest, size_t dest_size, const char *src) {
    size_t src_len = strlen(src);
    strncpy(dest, src, dest_size - 1);
    dest[dest_size - 1] = '\0';
    if (src_len >= dest_size) {
        printf("⚠️ 警告：截断 \"%s\" (%zu 字符 → %zu 字符)\n",
               src, src_len, dest_size - 1);
    }
}

int main(void) {
    char short_buf[10];
    safe_copy(short_buf, sizeof(short_buf), "This is a very long string");
    printf("结果: \"%s\"\n", short_buf);
    return 0;
}

🔴 挑战：用 strtok 安全解析 CSV

编写一个函数 int parse_csv(const char *csv, char fields[][64], int max_fields)，安全地解析 CSV 字符串。要求：

1. 不修改原始 csv 字符串（先复制一份再 strtok）
2. 每个字段最多 63 个字符 + \0
3. 用 strncpy 安全复制每个字段
4. 返回实际解析到的字段数
5. 测试数据："John,25,Engineer,New York"

#include <stdio.h>
#include <string.h>

#define FIELD_SIZE 64

int parse_csv(const char *csv, char fields[][FIELD_SIZE], int max_fields) {
    char work_buf[256];
    strncpy(work_buf, csv, sizeof(work_buf) - 1);
    work_buf[sizeof(work_buf) - 1] = '\0';

    int count = 0;
    char *token = strtok(work_buf, ",");
    while (token != NULL && count < max_fields) {
        strncpy(fields[count], token, FIELD_SIZE - 1);
        fields[count][FIELD_SIZE - 1] = '\0';
        count++;
        token = strtok(NULL, ",");
    }
    return count;
}

int main(void) {
    char fields[4][FIELD_SIZE];
    int n = parse_csv("John,25,Engineer,New York", fields, 4);
    for (int i = 0; i < n; i++) {
        printf("  fields[%d] = \"%s\"\n", i, fields[i]);
    }
    return 0;
}

  fields[0] = "John"
  fields[1] = "25"
  fields[2] = "Engineer"
  fields[3] = "New York"

故障排查 (FAQ)

Q：为什么 strlen("Hello") 返回 5，但 sizeof("Hello") 返回 6？

A：strlen 只计算 \0 之前的字符数（5），sizeof 计算整个字符串字面量占用的内存（5 字符 + 1 个 \0 = 6 字节）。

Q：能不能用 char* 代替 char[]？

A：可以只读访问，但不能修改。char *s = "Hello" 指向只读段（.rodata），s[0] = 'h' 会导致 Segmentation Fault。（技术上未定义行为 UB）

Q：strtok 可以嵌套使用吗？

A：标准版 strtok 不能嵌套——它内部用静态变量保存上次位置。如果需要嵌套分隔（比如先按行分隔，再按逗号分隔），使用 strtok_r（POSIX, 可重入）。

Q：strncpy 和 snprintf 哪个更安全？

A：两者都有边界检查。snprintf 更好：(1) 始终保证 \0 终止，(2) 返回值告诉你是否需要更大缓冲区，(3) 可以同时格式化多个值。

Q：UTF-8 字符串怎么正确计算字符数？

A：strlen() 返回的是字节数，不是 Unicode 字符数。例如 strlen("🌍") = 4（UTF-8 编码需 4 字节）。如果需要 Unicode 字符计数，使用 <uchar.h>（C11）或第三方库如 libunistring。

知识扩展 (选学)

缓冲区溢出攻击原理

缓冲区溢出不仅是 bug，还是经典的安全攻击方式。攻击者可以向栈溢出输入数据，覆盖函数的返回地址，让程序跳转到恶意代码：

栈内存布局：
  [ char buf[5] ] [ saved EBP ] [ return address ]

  strcpy(buf, "AAAAAAAAAAAAAAAAAAAAAAAA");
  → 'A' 覆盖 return address → 程序跳转到 0x41414141 → 崩溃或被劫持

这就是为什么 strcpy 被称为"危险的函数"。在安全关键代码中，它被直接列为禁止使用的函数。

C11 的 bounds-checking 扩展

C11 标准引入了可选的"边界检查"扩展（__STDC_LIB_EXT1__），提供了更安全的替代：

// C11 Annex K（可选实现）
#define __STDC_WANT_LIB_EXT1__ 1
#include <string.h>

strcpy_s(dest, dest_size, src);   // 类似 strncpy，但自动 \0 终止
strcat_s(dest, dest_size, src);
sprintf_s(buf, buf_size, "%s", str);

并非所有编译器都实现这些函数（glibc 默认不启用）。strncpy + 手动 \0 仍然是最广泛使用的安全模式。

Unicode 与多字节字符串

C 语言处理 Unicode 有多层方案：

对于大多数场景，UTF-8 char[] 是最实用的方案。strlen 得到字节数，如果需要字符数，需要解码 UTF-8 序列。

小结

本章深入学习了 C 语言字符串的安全处理方式：

• 字符串本质：null-terminated char 数组，\0 必不可少
• ASCII 内存图：字符串在栈上逐字节存储，末尾有 \0（ASCII 0）
• Python vs C：Python 自动管理内存和长度；C 需要手动管理一切
• 安全模式：strcpy → strncpy，sprintf → snprintf，始终手动设 \0
• 核心函数：strlen（长度）、strcmp（比较）、strchr/strstr（搜索）、strtok（分隔）
• 实战：安全 CSV 解析 = 复制原串 → 分隔 → strncpy 到字段缓冲区

核心术语：

• Null-terminated string / 以 null 结尾的字符串
• Null terminator (\0) / 字符串终止符
• Buffer overflow / 缓冲区溢出
• Undefined Behavior (UB) / 未定义行为
• Bounded string operation / 有界字符串操作

术语表

延伸阅读

• C 字符串安全：OWASP Buffer Overflow — 缓冲区溢出漏洞详解
• strlcpy/strlcat：OpenBSD 的替代方案（比 strncpy 更安全，但非标准）
• C11 Annex K：Bounds-checking interfaces — 标准库的安全扩展
• cppreference — string.h：C 字符串库参考

继续学习

• 上一章：数据类型
• 下一章：数组

本章代码位于仓库 src/basic/strings_sample.c。 运行 make build && make run 查看完整演示输出。

结构体（Structures）

想象你有一张名片。姓名、电话、邮箱打包在一张卡片上。你不需要拿三张纸条——一张写名字，一张写电话，一张写邮箱——递出去时还得担心会不会少了一张。

// 单个变量只能装一个值
int age = 20;
// 数组只能装同一种类型
int scores[5];
// 但一个"学生"既有字符串、又有整数、还有浮点数！

结构体就是 C 语言给出的答案——它像一个文件袋，可以把不同类型的数据装在一起，贴上标签，统一管理。

开篇故事

想象你有一张名片。上面印着姓名、电话、邮箱，三个信息打包在一张卡片上。你不需要带着三张纸条——一张写名字，一张写电话，一张写邮箱——每次递出去的时候还得担心会不会少了一张。

结构体就是名片的作用。它把不同类型的变量捆成一个整体，贴好字段名，统一管理。

struct Student {
    char name[32];
    int32_t age;
    float score;
};
// 一个学生 = 一份完整档案，不是三个散落在各处的抽屉

没有结构体之前，管理 100 个学生要同时维护三个数组——删一个学生，三个数组都要改。稍不留神就错位。有了结构体之后，学生是一个「实体」。删除就是删一份，传递就是传一份，代码的意图变得清晰。

"结构体让代码从'一堆变量'变成'有意义的东西'。"

本章适合谁

• 已经了解 C 语言基本变量和数据类型
• 想学怎么把不同类型的数据（int、char[]、float）打包在一起
• 好奇 Python 的 class / dict 在 C 语言中等价是什么的人

你会学到什么

• 结构体的定义与声明语法（struct 关键字）
• 结构体初始化（顺序初始化、指定初始化 designated initializers）
• 成员访问运算符（. 和 ->）
• 嵌套结构体（struct 里面套 struct）
• 把结构体作为函数参数传递
• 函数返回结构体

前置要求

• 完成 变量 和 数据类型 章节
• 理解 函数 的基本概念

第一个例子

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

// 定义一个结构体类型
struct Student {
    char name[32];
    int32_t age;
    float score;
};

int main(void) {
    // 创建一个 Student 变量并初始化
    struct Student stu = {"张三", 20, 95.5f};
    
    // 访问成员
    printf("姓名: %s\n", stu.name);
    printf("年龄: %d\n", stu.age);
    printf("成绩: %.1f\n", stu.score);
    
    return 0;
}

输出：

姓名: 张三
年龄: 20
成绩: 95.5

分步解析

1. struct Student { ... }; — 定义了一个结构体类型，包含三个成员
2. struct Student stu = {...} — 创建一个结构体变量并初始化
3. stu.name — 通过 . 运算符访问成员

原理解析

C struct vs Python class / dict

作为从 Python 过来的程序员，我第一次看到 C 的 struct 时，忍不住把它和 Python 做比较：

C struct 的内存布局（紧凑、连续）:
[ name: 32 bytes | age: 4 bytes | padding: 4 bytes | score: 4 bytes ] = 44 bytes (aligned to 48)

Python dict 的内存布局（分散、有哈希开销）:
dict object → hash table → {key: value, key: value, ...}
每个键值对还有独立的 str object + int object

1. 结构体定义语法

// 方式 1: 先定义类型，再声明变量
struct Student {
    char name[32];
    int32_t age;
    float score;
};

struct Student stu1;  // 声明变量

// 方式 2: 定义类型的同时声明变量
struct Student {
    char name[32];
    int32_t age;
    float score;
} stu2;  // 紧跟定义

// 方式 3: 匿名结构体（较少用）
struct {
    char name[32];
    int32_t age;
} stu3;  // 无类型名，只能声明这一次

2. 结构体初始化

// 方式 1: 顺序初始化
struct Student stu1 = {"李四", 21, 88.0f};

// 方式 2: 指定初始化 (C99, 推荐!)
struct Student stu2 = {
    .name = "王五",
    .age = 22,
    .score = 92.5f
};
// ✅ 指定初始化的优势: 可以只初始化部分成员
//    未指定的成员自动初始化为 0 / NULL
struct Student stu3 = { .age = 20 };  // 其余 = { '\0', 0, 0.0f }

// 方式 3: 逐个成员赋值
struct Student stu4;
// ❌ stu4 = {"赵六", 19, 76.0f}; // 错误！只能在声明时这样做
stu4.age = 19;
stu4.score = 76.0f;
// 对于数组成员，需要用 strcpy 或 strncpy

3. 成员访问（. 运算符）

struct Student stu = {.name = "小明", .age = 20, .score = 90.0f};

// 使用 '.' 访问成员
printf("姓名: %s\n", stu.name);   // 直接访问
stu.age = 21;                      // 修改成员
stu.score = stu.score + 5.0f;      // 参与运算

关键点：. 左侧必须是结构体变量本身（不是指针）。

4. 嵌套结构体

struct Date {
    int32_t year;
    int32_t month;
    int32_t day;
};

struct Student {
    char name[32];
    struct Date birthday;  // 嵌套结构体
    float score;
};

struct Student stu = {
    .name = "小红",
    .birthday = {.year = 2003, .month = 5, .day = 18},
    .score = 96.0f
};

// 访问嵌套成员用多个 '.'
printf("生日: %d-%02d-%02d\n",
       stu.birthday.year,
       stu.birthday.month,
       stu.birthday.day);

内存布局：struct 在内存中

struct Student stu = {.name="张三", .age=20, .score=95.5};

内存地址（低 → 高）:
┌──────────────┐
│  name[0..31] │  32 bytes  (姓名: "张三\0..." )
├──────────────┤
│      age     │   4 bytes  (20)
├──────────────┤
│   (padding)  │   4 bytes  (对齐填充，编译器自动插入)
├──────────────┤
│    score     │   4 bytes  (95.5f)
└──────────────┘
  Total: 44 bytes (通常对齐到 48)

💡 关键：结构体中可能存在 padding（填充字节），这是 CPU 内存对齐要求导致的。具体见下一章《结构体字段与内存布局》。

常见错误

❌ 错误 1: 未初始化的成员

struct Student stu;  // 未初始化！

// ❌ 成员的值的未定义的（garbage value）
printf("分数: %f\n", stu.score);  // 输出随机数！

✅ 修正: 初始化全部或归零

// 方式 A: 全部归零
struct Student stu = {0};

// 方式 B: 指定初始化（更安全）
struct Student stu = {
    .name = "",
    .age = 0,
    .score = 0.0f
};

❌ 错误 2: 用 == 比较两个结构体

struct Student a = {.name = "小明", .age = 20};
struct Student b = {.name = "小明", .age = 20};

// ❌ 不能用 == 比较结构体！C 标准不支持
// if (a == b) { ... }  // 编译错误！

✅ 修正: 逐成员比较或使用 memcmp（注意 padding 可能影响结果）

if (a.age == b.age && strcmp(a.name, b.name) == 0) {
    // 手动逐个比较
}

❌ 错误 3: struct 关键字遗忘

Student stu;  // ❌ C 语言不行！必须写 struct Student

✅ 修正: C 语言中必须写 struct 前缀（或者用 typedef）

struct Student stu;  // ✅ 正确
// 或者
typedef struct Student Student;
Student stu2;        // ✅ 用 typedef 后不需要 struct

动手练习

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

struct Book {
    char title[64];
    char author[32];
    float price;
};

int main(void) {
    struct Book b = {.title = "C Primer Plus", .author = "Stephen Prata", .price = 89.0f};
    printf("书名: %s\n", b.title);
    printf("作者: %s\n", b.author);
    printf("价格: ¥%.2f\n", b.price);
    return 0;
}

书名: C Primer Plus
作者: Stephen Prata
价格: ¥89.00

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

struct Student {
    char name[32];
    float score;
};

int main(void) {
    struct Student class[3] = {
        {.name = "张三", .score = 85.0f},
        {.name = "李四", .score = 92.0f},
        {.name = "王五", .score = 78.0f},
    };
    
    float sum = 0.0f;
    int32_t n = (int32_t)(sizeof(class) / sizeof(class[0]));
    for (int32_t i = 0; i < n; i++) {
        sum += class[i].score;
        printf("%s: %.1f\n", class[i].name, class[i].score);
    }
    printf("平均分: %.1f\n", sum / n);
    return 0;
}

张三: 85.0
李四: 92.0
王五: 78.0
平均分: 85.0

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

struct Point {
    float x;
    float y;
};

struct Circle {
    struct Point center;
    float radius;
};

float circle_area(struct Circle c) {
    return 3.14159f * c.radius * c.radius;
}

struct Circle create_circle(float x, float y, float r) {
    struct Circle c;
    c.center.x = x;
    c.center.y = y;
    c.radius = r;
    return c;  // 函数返回 struct
}

int main(void) {
    struct Circle c1 = create_circle(0.0f, 0.0f, 5.0f);
    struct Circle c2 = create_circle(3.0f, 4.0f, 3.0f);
    
    printf("圆1 面积: %.2f\n", circle_area(c1));
    printf("圆2 面积: %.2f\n", circle_area(c2));
    printf("面积差:  %.2f\n", circle_area(c1) - circle_area(c2));
    return 0;
}

圆1 面积: 78.54
圆2 面积: 28.27
面积差:  50.27

故障排查

struct Point { int32_t x; int32_t y; };
struct Point p = {1, 2, 3};  // ❌ 3 个值但只有 2 个成员

struct Point p = {.x = 1, .y = 2};  // ✅ 清晰且安全

// ❌ 不行——无限递归大小
struct Node {
    struct Node next;  // 编译错误！sizeof 无法计算
};

// ✅ 可以——指针大小固定
struct Node {
    int32_t data;
    struct Node *next;  // 指针大小固定（8 bytes on 64-bit）
};

typedef struct Student {
    char name[32];
    int32_t age;
} Student;

Student s = {"小明", 20};  // ✅ 不需要写 struct

知识扩展

typedef 简化结构体

// 传统写法（每次都要写 struct）
struct Point p1;

// typedef 写法（省略 struct）
typedef struct Point {
    float x;
    float y;
} Point;

Point p2;  // 简洁！

union —— 共享内存的 "结构体"

与 struct 类似，但所有成员共享同一块内存，大小等于最大成员：

union Data {
    int32_t i;
    float f;
    char str[8];
};
// sizeof(union Data) = 8（最长的成员）

小结

这一章我发现：

• struct 把不同类型的数据打包成一个有意义的整体
• 初始化有顺序初始化、指定初始化（.member = value）两种
• . 运算符访问结构体成员
• 嵌套结构体可以组合更复杂的数据模型
• 函数可以接收结构体参数、也可以返回结构体
• C 的 struct 比 Python class 更轻量——没有方法、没有动态属性、没有额外开销

术语表

延伸阅读

• cppreference: Structures and unions
• Beej's Guide: Structures
• K&R《C 程序设计语言》第 6 章：Structures

继续学习

结构体字段与内存布局（Struct Fields & Memory Layout）

上一章学会了 struct 的基本用法，但你可能有过这样的困惑——

struct A { char c; int i; };   // 1 + 4 = 5 字节？
struct B { int i; char c; };   // 4 + 1 = 5 字节？
// 但 sizeof 告诉我们: sizeof(A) = 8, sizeof(B) = 8！
// 多出来的 3 个字节去哪了？

答案就是 padding —— 编译器偷偷在字段之间插入了填充字节，让每个字段都"对齐"到 CPU 最舒服的地址上。本章我们就把这个幕后黑手揪出来。

开篇故事

想象你搬家打包，把一个杯子、一本厚书、一支笔依次塞进纸箱。杯子和书之间有空隙，书和笔之间也有空隙。这些空隙不是浪费——它们让物品不会因为紧贴而互相挤压变形。

编译器在 struct 里做的事情差不多。它给每个字段之间塞 padding（填充字节），让每个字段都"对齐"到 CPU 最舒服的位置上。int32_t 喜欢待在 4 的倍数地址上，int64_t 要 8 的倍数。编译器不会问你喜欢不喜欢，它直接帮你把间距排好。

struct A { char c; int32_t i; };   // 1 + 3(padding) + 4 = 8 字节
struct B { int i; char c; };       // 4 + 1 + 3(padding) = 8 字节
// 字段一样，顺序不同，sizeof 都是 8

第一次遇到这个问题的人会以为编译器出了 bug。它没有——它只是在遵循 CPU 的对齐规则。理解了这一点，你就不会再惊讶于 sizeof 永远比你想的大。

"padding 不是浪费，而是 CPU 的效率税。"

本章适合谁

• 已经学过 结构体基础，知道 struct 怎么用
• 好奇 sizeof 为什么算出来比预料大的 C 学习者
• 想了解底层内存布局的嵌入式/系统程序员

你会学到什么

• 结构体字段逐个访问的细节
• struct padding（填充字节）与 alignment（内存对齐）
• sizeof 在含 padding 的结构体上的表现
• __attribute__((packed)) 的作用与代价
• 位域（Bit Fields）的用法
• 嵌套结构体的字段访问
• 内存布局的 ASCII 可视化

前置要求

• 完成 结构体基础 章节
• 了解 C 语言基本数据类型的大小（int32_t = 4 字节等）

第一个例子

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

struct Compact {
    int32_t a;    // 4 bytes
    int32_t b;    // 4 bytes
};

struct Gappy {
    char   a;     // 1 byte
    int32_t b;    // 4 bytes (需要 4 字节对齐)
    char   c;     // 1 byte
};

int main(void) {
    printf("Compact: sizeof = %zu\n", sizeof(struct Compact));  // 8
    printf("Gappy:   sizeof = %zu\n", sizeof(struct Gappy));    // 12 (!)
    return 0;
}

明明 Gappy 只有 1+4+1 = 6 字节的真实数据，sizeof 却是 12！中间有 6 字节是 padding。

原理解析

1. 字段访问细节

struct Student {
    char name[32];
    int32_t age;
    float score;
};

struct Student stu = {.name = "小明", .age = 20, .score = 95.0f};

// ✅ 正常访问
printf("%s\n", stu.name);   // 直接访问
stu.age = 21;               // 修改

// ✅ 通过指针访问
struct Student *ptr = &stu;
printf("%d\n", ptr->age);   // -> 等价于 (*ptr).age

2. 内存对齐（Alignment）与 Padding

CPU 读取内存时，不是按字节一个个读的，而是按"字"（word）读取的。在 64 位机器上，一个字通常是 8 字节。

对齐规则：

• int8_t（1 字节）—— 任意地址
• int16_t（2 字节）—— 地址必须是 2 的倍数
• int32_t（4 字节）—— 地址必须是 4 的倍数
• int64_t（8 字节）—— 地址必须是 8 的倍数

struct Gappy { char a; int32_t b; char c; };

ASCII 内存布局:

偏移地址:  0    1    2    3    4    5    6    7    8    9   10   11
         ┌────┐ ┌──────────────────┐ ┌────┐ ┌──────────┐ ┌──────────┐
字段:    │  a │ │    PADDING       │ │     b      │ │  c   │ │ PADDING  │
         └────┘ └──────────────────┘ └────────────┘ └────┘ └──────────┘
大小:     1B       3 bytes (补到   4 bytes         1B      3 bytes
                    4 字节边界)                          (补齐到 8 的倍数)

总计: 12 bytes

为什么这样？
- offset 0: a 放在 0 (任意地址都可以)
- offset 1-3: PADDING! b 必须放在 4 的倍数地址
- offset 4-7: b 放在 [4] (✅ 4 的倍数)
- offset 8: c 放在 [8]
- offset 9-11: PADDING! struct 总大小必须是最大对齐数（4）的倍数

C struct vs Python dict 内存对比

C struct (紧凑、连续、编译器控制布局):
  ┌──────────────────────────────────────┐
  │ struct Header {                      │
  │   uint8_t  version;  // 1 byte       │  ← offset 0
  │   uint32_t length;   // 4 bytes      │  ← offset 4 (padding +3)
  │   uint8_t  flag;     // 1 byte       │  ← offset 8
  │   /* padding x3 */                  │  ← offset 9,10,11
  │ }                                    │         Total: 12 bytes
  └──────────────────────────────────────┘

Python dict (分散、有哈希表 + 对象开销):
  ┌──────────────────────────┐         ┌──────────────────┐
  │ dict object (240 bytes)  │────┐   │ int object (28 b)│
  │ hash table               │────┤   └──────────────────┘
  │  "version" → pointer─────┘    │
  │  "length"  → pointer─────┐   │
  │  "flag"    → pointer─────┐│   │
  └──────────────────────────┘│   │
                              └───┤  ┌──────────────────┐
                                  │ │ int object (28 b)│
                              ┌───┘  └──────────────────┘
                              │
                              └───┐  ┌──────────────────┐
                                  │ │ int object (28 b)│
                                  │  └──────────────────┘
                                  └──
  Total: ~324 bytes (比 C struct 大 27 倍!)

3. 优化字段顺序减少 padding

// ❌ 浪费的排列: 12 bytes
struct Bad {
    char   a;     // 1 + 3 padding
    int32_t b;    // 4
    char   c;     // 1 + 3 padding
};

// ✅ 紧凑的排列: 8 bytes
struct Good {
    int32_t b;    // 4
    char   a;     // 1
    char   c;     // 1 + 2 padding
};

// 排序技巧: 按大小从大到小排列字段
//  int64_t → int32_t → int16_t → int8_t

4. __attribute__((packed)) 去除 padding

struct __attribute__((packed)) Packed {
    char   a;     // 1 byte
    int32_t b;    // 4 bytes (不再有 padding!)
    char   c;     // 1 byte
};
// sizeof = 6 字节! 紧凑了。

// 代价: CPU 可能需要多次内存访问来读取 b（性能下降）
// 某些架构（如 ARM）直接不允许不对齐访问 → 硬件异常

5. 位域（Bit Fields）

当字段只需要很少的 bit 时，可以用位域节省空间：

struct Flags {
    unsigned int enabled : 1;   // 只用 1 bit
    unsigned int level   : 3;   // 3 bits (0-7)
    unsigned int reserved: 4;   // 4 bits
};
// sizeof = 4 bytes (一个 unsigned int)

// ⚠️ 位域的限制:
// - 不能取地址 (&flags.enabled 是非法的)
// - 不同编译器可能有不同的布局
// - 不适合跨平台二进制协议

常见错误

❌ 错误 1: 假设 struct 大小等于字段大小之和

struct S { char c; int32_t i; };
// ❌ 错误假设: sizeof(struct S) == 1 + 4 == 5
// ✅ 实际: sizeof(struct S) == 8（有 3 字节 padding）

✅ 修正: 用 sizeof 和 offsetof 检查实际布局

#include <stddef.h>
printf("sizeof: %zu\n", sizeof(struct S));
printf("offset of c: %zu\n", offsetof(struct S, c));
printf("offset of i: %zu\n", offsetof(struct S, i));

❌ 错误 2: 网络传输时直接 send(&struct, sizeof(struct))

struct NetPkt {
    uint8_t  version;
    uint32_t length;
};
// ❌ 直接发送 struct 会把 padding 也发过去！
// 对端用不同编译器或对齐规则时，字段就错位了

✅ 修正: 序列化/打包为连续字节再发送

uint8_t buf[5];
buf[0] = pkt.version;
// 手动编码 length
buf[1] = (pkt.length >> 24) & 0xFF;
buf[2] = (pkt.length >> 16) & 0xFF;
buf[3] = (pkt.length >> 8) & 0xFF;
buf[4] = pkt.length & 0xFF;
send(sock, buf, 5);

❌ 错误 3: 位域跨平台传输

struct Flags f = {.enabled = 1, .level = 3};
send(sock, &f, sizeof(f));  // ❌ 位域的 bit 布局因编译器而异

✅ 修正: 位域不要用于网络/文件等二进制协议。

动手练习

struct A { char a; char b; int32_t c; };
struct B { int32_t c; char a; char b; };
struct C { char a; int32_t c; char b; };

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

struct __attribute__((packed)) PackedGappy {
    char a;
    int32_t b;
    char c;
};

int main(void) {
    printf("PackedGappy sizeof = %zu (期望 6)\n", sizeof(struct PackedGappy));
    return 0;
}

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

struct Example {
    char   a;
    int32_t b;
    char   c;
};

int main(void) {
    printf("字段    offset  sizeof\n");
    printf("a       %-7zu  %zu\n",  offsetof(struct Example, a), sizeof(((struct Example*)0)->a));
    printf("b       %-7zu  %zu\n",  offsetof(struct Example, b), sizeof(((struct Example*)0)->b));
    printf("c       %-7zu  %zu\n",  offsetof(struct Example, c), sizeof(((struct Example*)0)->c));
    printf("struct total: %zu\n", sizeof(struct Example));
    return 0;
}

故障排查

[ a: 1B ] [ padding: 7B ] [ b: 8B ] = 16B

offsetof(struct S, field)  // 返回 field 距离 struct 起点的字节偏移

知识扩展

C 标准规定的对齐保证

C 标准要求编译器保证：struct 的起始地址对齐到其最大成员的对齐要求。

struct { char c; int32_t i; };
// 最大对齐 = 4 (int32_t)
// 所以整个 struct 必须放在 4 的倍数地址上
// 总大小必须是最⼤对齐的倍数 → 8

_Alignof 与 _Alignas（C11）

#include <stdalign.h>

printf("alignof(int32_t) = %zu\n", alignof(int32_t));  // 4

// C11 _Alignas 指定对齐
struct Aligned {
    _Alignas(16) int32_t data[4];  // 强制 16 字节对齐
};

小结

这一章我发现：

• sizeof(struct) ≠ 各字段大小之和——编译器会插入 padding 满足对齐
• 字段排列顺序影响 struct 大小——大字段在前更紧凑
• __attribute__((packed)) 可以消除 padding，但有性能代价
• 位域可以进一步压缩空间，但不可移植
• offsetof 和 sizeof 是排查 struct 内存布局的好帮手
• C struct 比 Python dict 紧凑得多——系统编程的效率优势

术语表

延伸阅读

• cppreference: Alignment
• cppreference: Bit fields
• Beej's Guide: Structures and Alignment
• C11 标准 §6.2.8: Alignment

继续学习

枚举与联合体（Enums & Unions）

"枚举是给整数起了名字，联合体是让多种类型共享同一块内存。" —— 我发现

开篇故事

想象墙上有一盏灯，旁边有个开关。这个开关只有两档：ON 和 OFF。你不会用「随便拧到一个角度」来控制它——它只能取其中的一个状态，不能同时又是开又是关。

枚举就是程序里的电灯开关。它定义了一组有限的、互斥的选项，每次只能选一个。

enum LightState { OFF, DIM, BRIGHT };
enum LightState lamp = DIM;  // 当前只有一个状态
// lamp 不可能同时是 OFF 和 BRIGHT

在枚举出现之前，程序员用 #define 来定义状态码。宏也能工作，但它没有任何类型保护——set_state(999) 能通过编译，因为 999 也是一个合法的整数。枚举引入了类型检查的语义约束，让「传入非法状态」这件事在代码层面变得更明显。

枚举和联合体组合之后，还能实现更复杂的「多状态选一」模式。这是 C 语言里最接近 Rust 的 enum 的写法。

"枚举的本质不是数字，而是'只能选一个'的承诺。"

本章适合谁

• 用过 #define 定义状态码，但踩过类型安全坑的人
• 想知道 C 语言怎么实现"多种类型之一"的数据结构
• 对 Rust enum、Python Enum 有了解，想对比 C 的枚举
• 想掌握 tagged union 模式的 C 学习者

你会学到什么

• enum 的定义、使用与底层原理
• 枚举与 #define 常量的对比与选择
• 枚举值的显式赋值与自动递增
• 将枚举作为函数参数和返回值
• Tagged Union 模式（枚举 + 联合体的组合）
• 枚举的边界验证与错误处理
• 实际应用：状态机、错误码、配置选项

前置要求

• 了解基本的 int、float、结构体（struct）概念
• 理解函数的参数传递与返回值
• 能编译运行 .c 文件

如果还没学结构体，建议先看「数据类型」章节。

第一个例子：用枚举定义星期

#include <stdio.h>

enum Weekday { MON, TUE, WED, THU, FRI, SAT, SUN };

int main(void) {
    enum Weekday today = MON;
    printf("Today is day %d\n", today);  /* 输出: 0 */

    today = FRI;
    printf("Friday is day %d\n", today);  /* 输出: 4 */
    return 0;
}

运行结果：

Today is day 0
Friday is day 4

看起来枚举就是把整数起了个好看的名字？不完全是。让我深入解释。

原理解析

1. 枚举的本质：命名的整数常量

enum 定义了一个枚举类型，它里面的每个成员（enumerator）都被编译器分配了一个整数值，默认从 0 开始递增：

enum Weekday { MON, TUE, WED, THU, FRI, SAT, SUN };
/*  等价于:
    MON = 0, TUE = 1, ..., SUN = 6
*/

我的理解：枚举是"带自我文档的整数"——FRI 比 4 更能表达意图，但底层仍然是整数运算。

2. 显式赋值

枚举成员可以显式指定值：

enum Permission {
    READ    = 1,   /* 0b001 */
    WRITE   = 2,   /* 0b010 */
    EXECUTE = 4    /* 0b100 */
};

也可以省略后续值，编译器自动递增：

enum ErrorCode {
    OK = 0,
    ERR_INVALID_ARG,   /* = 1 */
    ERR_NULL_PTR,      /* = 2 */
    ERR_TIMEOUT = 100, /* 重新指定 */
    ERR_IO           /* = 101 */
};

3. ASCII 内存布局

枚举在内存中的存储大小与 int 相同（通常是 4 字节）：

enum Color { RED, GREEN, BLUE };

变量: enum Color c = GREEN;

内存布局:
┌────────────────────────────────┐
│  0x00000001  (4 字节, int)    │
└────────────────────────────────┘
    enum 底层就是 int，RED=0, GREEN=1, BLUE=2

sizeof(enum Color) == sizeof(int)  ← 通常如此

注意：C 标准不强制规定枚举的大小，只要求它至少能容纳所有枚举值。实际实现中，大多数编译器用 int。

4. 与 Python / JavaScript 对比

C 的枚举偏底层，它的设计哲学是"枚举是整数的语法糖"，但通过类型名称提供了一定程度的语义约束。

5. 枚举作为函数参数

typedef enum Loglevel {
    LOG_DEBUG,
    LOG_INFO,
    LOG_WARN,
    LOG_ERROR
} LogLevel;

void logger(LogLevel level, const char *msg) {
    const char *prefix;
    switch (level) {
        case LOG_DEBUG: prefix = "DEBUG"; break;
        case LOG_INFO:  prefix = "INFO";  break;
        case LOG_WARN:  prefix = "WARN";  break;
        case LOG_ERROR: prefix = "ERROR"; break;
    }
    printf("[%s] %s\n", prefix, msg);
}

优势：调用时只能传递枚举成员，比传递裸 int 更安全——虽然技术上仍然可以强转，但编译器会发出警告。

常见错误（Error-First）

❌ 错误 1：给枚举赋任意整数值

enum Status { STATUS_OK, STATUS_FAIL };

enum Status s = (enum Status)99;  /* ❌ 编译可能不报错！但语义错误 */
/* 99 不是合法的 Status 值，但 C 允许这种隐式转换 */

这是 C 枚举的"弱点"——它基于 int，所以你可以赋任何 int 给它。

✅ 修复：在关键位置添加验证：

#include <stdbool.h>

bool is_valid_status(enum Status s) {
    return s == STATUS_OK || s == STATUS_FAIL;
}

void handle_status(enum Status s) {
    if (!is_valid_status(s)) {
        printf("Error: invalid status code %d\n", s);
        return;
    }
    /* 安全处理 */
}

我的模式：所有枚举参数在进入核心逻辑前，先用 switch + default 验证。

void safe_handle(enum Status s) {
    switch (s) {
        case STATUS_OK:  do_ok(); break;
        case STATUS_FAIL: do_fail(); break;
        default:
            /* ❌ 捕获非法值 */
            fprintf(stderr, "Unknown status: %d\n", s);
            return;
    }
}

❌ 错误 2：枚举未覆盖所有值，switch 缺少 default

编译器 -Wswitch 可以提醒，但不是 -Werror：

enum Color { RED, GREEN, BLUE };

void print_color(enum Color c) {
    switch (c) {
        case RED: printf("red\n"); break;
        case GREEN: printf("green\n"); break;
        /* 缺少 BLUE 和 default! */
    }
}

✅ 修复：永远在 switch 枚举时加 default：

void print_color(enum Color c) {
    switch (c) {
        case RED:   printf("red\n"); break;
        case GREEN: printf("green\n"); break;
        case BLUE:  printf("blue\n"); break;
        default:    printf("unknown(%d)\n", c); break;
    }
}

动手练习

🟢 练习 1：定义月份枚举并打印

/* 定义 enum Month { JAN=1, FEB, ..., DEC }
   用 switch 打印中文月份名 */

#include <stdio.h>

enum Month { JAN = 1, FEB, MAR, APR, MAY, JUN,
             JUL, AUG, SEP, OCT, NOV, DEC };

void print_month(enum Month m) {
    switch (m) {
        case JAN: printf("一月"); break;
        case FEB: printf("二月"); break;
        case MAR: printf("三月"); break;
        case APR: printf("四月"); break;
        case MAY: printf("五月"); break;
        case JUN: printf("六月"); break;
        case JUL: printf("七月"); break;
        case AUG: printf("八月"); break;
        case SEP: printf("九月"); break;
        case OCT: printf("十月"); break;
        case NOV: printf("十一月"); break;
        case DEC: printf("十二月"); break;
        default: printf("未知"); break;
    }
}

🟡 练习 2：模拟简易状态机

/* 定义灯的状态：OFF、DIM、BRIGHT
   实现 next_state() 函数：OFF → DIM → BRIGHT → OFF
   用 enum 参数和返回值 */

#include <stdio.h>

typedef enum LightState { LIGHT_OFF, LIGHT_DIM, LIGHT_BRIGHT } LightState;

LightState next_state(LightState current) {
    switch (current) {
        case LIGHT_OFF:   return LIGHT_DIM;
        case LIGHT_DIM:   return LIGHT_BRIGHT;
        case LIGHT_BRIGHT: return LIGHT_OFF;
        default:          return LIGHT_OFF;  /* safety */
    }
}

const char *state_name(LightState s) {
    switch (s) {
        case LIGHT_OFF:    return "OFF";
        case LIGHT_DIM:    return "DIM";
        case LIGHT_BRIGHT: return "BRIGHT";
        default:           return "UNKNOWN";
    }
}

联合体的奥秘

6. Union（联合体）基础

union 是一种特殊的数据类型，它的所有成员共享同一块内存。大小等于最大的成员：

union Data {
    int i;
    double d;
    char str[16];
};

sizeof(union Data);  /* = 16 字节（str 最大）*/

内存布局:
┌────────────────────────────────────┐
│ i (4 bytes)                        │
│ d (8 bytes, overlaps with i)       │
│ str[16] (16 bytes, overlaps all)   │
│ ←── 同一块内存, 你写哪个就读哪个 ──→  │
└────────────────────────────────────┘

我的理解：结构体是"并排摆放的柜子"，联合体是"同一个柜子，什么都能往里放，但一次只能放一种东西"。

7. 危险：Union 类型不安全

union Data u;
u.d = 3.14;    /* 写入 double */
printf("%d\n", u.i);  /* ❌ 以 int 读取 double → 垃圾值！*/

编译器不会检查你读写的是否是同一种类型——这就是联合体最大的陷阱。

Tagged Union 模式

8. 枚举 + 联合体 = 类型安全的变体

要安全地使用 union，必须搭配一个枚举来标记当前存储的类型，这就是Tagged Union（带标签联合体）模式：

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

enum ValueKind { VALUE_INT, VALUE_DOUBLE, VALUE_STRING };

struct Variant {
    enum ValueKind tag;        /* 标签：当前存储什么类型 */
    union {
        int32_t int_val;
        double  double_val;
        const char *str_val;
    } data;
};

struct Variant 内存布局:
┌──────────────┬────────────────────────┐
│ tag (enum)   │ data (union)            │
│ = 4 字节     │ = 最大成员大小 (如 8)   │
│ 记录类型     │ 实际存储的数据          │
└──────────────┴────────────────────────┘

现在可以安全地构造和访问：

struct Variant make_int(int32_t v) {
    struct Variant var = { .tag = VALUE_INT, .data.int_val = v };
    return var;
}

struct Variant make_double(double v) {
    struct Variant var = { .tag = VALUE_DOUBLE, .data.double_val = v };
    return var;
}

void print_variant(const struct Variant *v) {
    switch (v->tag) {
        case VALUE_INT:
            printf("int: %d\n", v->data.int_val);
            break;
        case VALUE_DOUBLE:
            printf("double: %.2f\n", v->data.double_val);
            break;
        case VALUE_STRING:
            printf("string: %s\n", v->data.str_val);
            break;
        default:
            printf("unknown type\n");
            break;
    }
}

9. 实际应用：错误码模式

C 语言中常见的另一种枚举用法是错误码，配合返回值做 Error-First 风格：

typedef enum Result {
    RESULT_OK = 0,
    RESULT_ERR_NULL,
    RESULT_ERR_IO,
    RESULT_ERR_TIMEOUT
} Result;

Result open_file(const char *path) {
    if (path == NULL) return RESULT_ERR_NULL;
    /* ... 模拟文件操作 ... */
    return RESULT_OK;
}

故障排查（FAQ）

Q: enum 和 #define 到底该用哪个？

我的建议：定义一组相关常量时优先用 enum。只在需要"文本替换"（如宏函数）或条件编译（#ifdef）时用 #define。

Q: enum 的大小一定是 sizeof(int) 吗？

大多数时候是，但 C 标准允许编译器优化。GCC 可以用 -fshort-enums 让枚举使用 1 字节或 2 字节（如果能容纳所有值）。跨平台编程时应使用 sizeof() 而非假设。

Q: 可以用 enum 做位标志（bit flags）吗？

可以。用 2 的幂次赋值：

typedef enum Permission {
    PERM_READ    = 1 << 0,   /* 0b001 */
    PERM_WRITE   = 1 << 1,   /* 0b010 */
    PERM_EXEC    = 1 << 2,   /* 0b100 */
} Permission;

Permission p = PERM_READ | PERM_WRITE;  /* 组合 */
/* 检查: if (p & PERM_WRITE) */

知识扩展（选学）

X-Macro：枚举与字符串同步

X-Macro 是一种高级模式，让枚举值与字符串数组始终保持同步：

#define COLOR_LIST \
    X(RED,   0)    \
    X(GREEN, 1)    \
    X(BLUE,  2)

/* 生成枚举 */
#define X(name, val) COLOR_##name = val,
enum ColorName { COLOR_LIST };
#undef X

/* 生成名称数组 */
#define X(name, val) #name,
const char *color_names[] = { COLOR_LIST };
#undef X

/* color_names[COLOR_RED] == "RED" */

这是 C 语言中一种"编译期元编程"技巧。

小结

祝贺！你已经掌握了 C 语言的枚举与联合体。让我总结一下——

• enum 是命名的整数常量，有类型但底层是 int
• 枚举 vs #define：枚举更安全、可调试、支持自动递增
• union 的所有成员共享同一块内存，大小 = 最大成员
• Tagged Union（枚举 + 联合体）是 C 中实现类型安全变体的标准模式
• 枚举验证：永远用 switch + default 覆盖所有枚举值，防止非法值
• 位标志：枚举可以用位移值做组合操作
• 枚举的边界：C 允许给枚举赋任意 int，运行时需验证

我的理解：枚举不是银弹——它提供了更好的表达力，但不像 Rust 的 enum 那样严格。理解它既是"命名的整数"也是"带标签的类型"，你就能在安全和效率之间找到最佳平衡。

术语表

延伸阅读

• cppreference: Enum types (C)
• cppreference: Union types (C)
• K&R《C 程序设计语言》第 1.6、6.5 章
• 《C Primer Plus》第 11 章：结构体和枚举

继续学习

枚举和联合体让你掌握了 C 语言中标识多种状态和共享内存的基础。下一章我们将深入学习作用域与生命周期——理解变量在哪里可见、什么时候创建、什么时候销毁，这将让你写出更安全的代码。

💡 提示：检查你的代码里所有 #define 定义的状态码，尝试替换为 enum。你会发现代码的可读性和安全性都提升了！

← 上一章：指针运算 | 下一章：作用域与生命周期 →

作用域与生命周期（Scope & Lifetime）

"变量就像人一样：出生在某些地方，活在特定的范围内，然后消失在某个时刻。" —— 我发现

开篇故事

想象你走进一栋大楼。每扇门进去都是一个独立的房间——客厅的家具不在卧室里，厨房的刀叉不在书房里。你在 A 房间里声明的东西，B 房间看不到，也碰不到。当你离开一个房间，里面的一切就自动归还给大楼，不再属于你。

作用域就是 C 语言里的「房间」。用 { } 划出一片空间，在里面声明的变量只在这个空间里可见。出了 { }，变量就消失了——像离开房间时门被锁上，里面的东西你再也拿不到。

{
    int x = 10;      // x 在「这个房间」里
    printf("%d\n", x);  // ✅ 看得到
}
// printf("%d\n", x); // ❌ 门已经关上了

最常见的陷阱，就是试图从门外拿走房间里的东西——比如返回一个局部变量的地址。变量已经「离开房间」了，指针却还指着那片空间。编译器不一定拦你，但结果可能是随机的。

"变量在哪个房间声明，就在哪个房间可见。门关了，东西就没了。"

本章适合谁

• 遇到过"偶尔正常偶尔崩溃"的 bug，怀疑是内存问题的人
• 用过 static 但说不清它到底做了什么的人
• 想理解 extern 关键字在跨文件编程中作用的人
• 对 Python/Rust/Go 等有垃圾回收的语言有了解，想对比 C 的手动内存管理

你会学到什么

• 作用域的四个层次：块作用域、函数作用域、文件作用域、全局作用域
• static 关键字的双重身份：函数内 vs 文件级
• extern 跨文件链接的机制
• 局部变量与全局变量的生命周期
• Dangling pointer（悬垂指针）与 use-after-free
• 为什么"返回局部变量地址"是未定义行为
• 安全的作用域管理模式

前置要求

• 了解变量的声明与初始化
• 理解函数调用与返回
• 掌握指针的基本概念（* 取内容、& 取地址）

如果还没学指针，建议先看「指针运算」章节。

第一个例子：块作用域

#include <stdio.h>

int main(void) {
    int x = 10;
    printf("外层: x = %d\n", x);

    {
        int x = 20;   /* 新的 x，遮蔽外层的 x */
        printf("内层: x = %d\n", x);
    }
    /* 内层的 x 已经消失了 */
    printf("回到外层: x = %d\n", x);
    return 0;
}

运行结果：

外层: x = 10
内层: x = 20
回到外层: x = 10

内层的 x 在 { } 结束后就"死"了，外层的 x 不受影响。这正是作用域的力量。

原理解析

1. 块作用域（Block Scope）

在 C 语言中，任何一个 { } 代码块都创建了一个新的作用域。在块内声明的变量只在该块内可见：

{
    int a = 1;
    if (a > 0) {
        int b = 2;  /* b 只在 if 块内可见 */
    }
    /* printf("%d", b); ❌ b 不存在了！ */
}

ASCII 栈图——变量的进出：

栈帧（Stack Frame）

内存地址 ↑
┌────────────────┐
│ main 的局部变量 │ ← main 作用域开始
│   x = 10       │
│                │
├────────────────┤
│ { } 块的局部变量 │ ← 进入 { }，新的"架子"
│   x = 20       │   这个 x 在栈帧的较高位置
│                │
├────────────────┤ ← } 关闭，架子抽走
│                │   内部 x 被销毁
│   x = 10       │ ← 恢复外层的 x
│                │
└────────────────┘ ← main 作用域结束，整个栈帧弹出

我的理解：把栈帧想象成一层层抽屉——{ } 打开时放一个新抽屉，} 关闭时把抽屉抽走。抽屉里的东西随抽屉一起消失。

2. 变量遮蔽（Shadowing）

内层可以声明与外层同名的变量，这叫"遮蔽"（Shadowing）：

int count = 10;
{
    int count = 5;  /* 遮蔽外层的 count */
    printf("%d\n", count);  /* 输出 5 */
}
printf("%d\n", count);  /* 输出 10 */

我的建议：虽然 C 允许遮蔽，但大多数风格指南不推荐这样做——它容易让人混淆，降低代码可读性。

3. 函数作用域（Function Scope）

函数内的参数和局部变量只在函数体内可见：

void greet(const char *name) {  /* name 是参数，作用域在函数内 */
    int len = 0;                /* len 也是函数局部变量 */
    /* ... */
}
/* name 和 len 在这里都不存在 */

函数作用域还有一个特殊的"标签作用域"（Label Scope）——goto 的标签在整个函数内可见：

void example(void) {
    goto end;
    int x = 10;  /* 注意：跳过初始化是合法的，但不推荐 */
    end:
    printf("done\n");
}

4. 文件作用域（File Scope）

在函数外部声明的变量/函数，作用域是整个当前源文件：

/* file.c */
int file_counter = 0;  /* 文件级变量，本文件所有函数可见 */

static int secret = 42; /* 文件级 + static：只有本文件可见 */

void func_a(void) {
    file_counter++;  /* 可以访问 */
    secret++;        /* 可以访问 */
}

void func_b(void) {
    file_counter++;  /* 可以访问 */
}

5. 全局作用域（External Linkage）

在函数外声明且没有 static 的变量/函数，具有外部链接（external linkage），其他源文件可以通过 extern 声明来访问：

/* module_a.c */
int shared_data = 100;  /* 外部链接：其他文件可访问 */

/* module_b.c */
extern int shared_data;  /* 声明：shared_data 在别处定义 */

void use_shared(void) {
    printf("shared_data = %d\n", shared_data);
}

对比表：

6. static 的双重身份

static 在 C 语言中有两种完全不同的含义，取决于它出现在哪里：

6a. 函数内部的 static：延长生命周期

void counter(void) {
    static int count = 0;  /* 只初始化一次，程序结束后才销毁 */
    count++;
    printf("called %d times\n", count);
}

/* 第1次调用: called 1 times
   第2次调用: called 2 times
   ... */

对比普通局部变量：

┌──────────────────────┐  时间线
│ 局部变量: count = 0  │ ← 函数返回 → 销毁
│                      │ ← 下次调用 → 重新创建为 0
├──────────────────────┤
│ static 变量: count   │ ← 函数返回 → 保留值
│         ↑ 存活       │ ← 下次调用 → 保持上次值
└──────────────────────┘

我的理解：函数内的 static = "活到程序结束，但只能在这个函数里看到"。

6b. 文件级的 static：限制可见性

/* utils.c */
static void helper(void) {  /* 只有 utils.c 内部能调用 */
    /* ... */
}

void public_api(void) {     /* 其他文件可以通过 extern 调用 */
    helper();
}

这是模块化的基础——用 static 隐藏实现细节。

7. ASCII 内存布局全览

C 程序在内存中的分布：

内存地址 ↑

┌──────────────────────────┐
│  栈 (Stack)              │ ← 局部变量、函数参数
│  auto 变量               │    生命周期 = 块/函数
│                          │
├──────────────────────────┤
│                          │
│  堆 (Heap)               │ ← malloc/calloc 分配
│  动态内存                │    生命周期 = 手动控制
│                          │
├──────────────────────────┤
│  已初始化数据段          │ ← 全局变量、static 变量
│  .data                   │    (有初值的)
├──────────────────────────┤
│  未初始化数据段          │ ← 全局 = 0 的变量
│  .bss                    │    (零初始化的)
├──────────────────────────┤
│  只读数据段              │ ← 字符串字面量
│  .rodata                 │    ("hello")
├──────────────────────────┤
│  代码段                  │ ← 函数指令
│  .text                   │    (只读, 可执行)
└──────────────────────────┘

生命周期对照：

• 栈变量 → 离开作用域即销毁
• 堆变量 → free() 才销毁
• .data/.bss 变量 → 程序结束时销毁

常见错误（Error-First）

❌ 错误 1：返回局部变量的地址

int *get_pointer(void) {
    int x = 42;
    return &x;  /* ❌ x 是局部变量，函数返回后 x 不存在 */
}

int main(void) {
    int *p = get_pointer();
    printf("%d\n", *p);  /* ❌ 未定义行为！（Undefined Behavior） */
    return 0;
}

x 存储在栈上，函数返回后这片栈空间被回收。p 指向的内存可能已被其他数据覆盖。

✅ 修复方式 1：用 static 局部变量

int *get_pointer(void) {
    static int x = 42;  /* static: 存储在 .data 段，生命周期 = 整个程序 */
    return &x;
}

✅ 修复方式 2：用 malloc 动态分配

int *get_pointer(void) {
    int *x = malloc(sizeof(int));
    *x = 42;
    return x;  /* 堆内存，函数返回后仍然有效 */
}
/* 注意：调用者必须 free() */

✅ 修复方式 3：让调用者分配

void get_value(int *result) {
    *result = 42;  /* 直接写入调用者提供的空间 */
}

❌ 错误 2：Dangling Pointer（悬垂指针）

int *dangling = NULL;

void create_array(void) {
    int arr[10] = {0};
    dangling = arr;  /* 记录指针 */
}
/* arr 已在函数返回时销毁，dangling 成为"悬垂指针" */

void use_it(void) {
    printf("%d\n", dangling[0]);  /* ❌ 未定义行为！可能崩溃 */
}

✅ 修复：永远不要持有指向已销毁对象的指针。如果必须跨函数传递，用堆分配或让调用者管理内存。

❌ 错误 3：Use-After-Free

#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int) * 10);
    p[0] = 42;

    free(p);        /* p 已被释放 */
    p[0] = 99;      /* ❌ 写入已释放的内存！ */
    printf("%d\n", p[0]);  /* ❌ 读取已释放的内存！ */

    return 0;
}

✅ 修复：free() 后立即将指针置为 NULL：

free(p);
p = NULL;  /* 防止意外再次使用 */
/* p[0] = 99; ← 现在会立刻崩溃（段错误），比静默损坏好 */

❌ 错误 4：extern 声明与实际类型不一致

/* a.c */
int data = 100;

/* b.c */
extern double data;  /* ❌ 声明为 double，实际是 int */

void wrong(void) {
    printf("%f\n", data);  /* ❌ 以 double 方式读取 int → 垃圾值！ */
}

✅ 修复：用头文件统一管理 extern 声明，不要在各处重复写。

动手练习

🟢 练习 1：观察变量生命周期

/* 写一个函数，声明一个 static int 计数器
   每次调用加 1 并打印。在另一个函数中调用它 5 次
   验证计数器的值在调用间保持 */

#include <stdio.h>

void tick(void) {
    static int count = 0;
    count++;
    printf("tick #%d\n", count);
}

int main(void) {
    for (int i = 0; i < 5; i++) {
        tick();
    }
    return 0;
}
/* 输出: tick #1, tick #2, ..., tick #5 */

🟡 练习 2：文件级 static 的模块化

/* 写一个文件 util.c：
   - static 函数 helper() 只做内部辅助
   - 公开函数 public_func() 调用 helper()
   另一个文件 main.c 只能调用 public_func()，不能调用 helper() */

/* util.c */
static int helper(int x) {
    return x * 2;
}
int public_func(int x) {
    return helper(x) + 1;
}

/* main.c */
#include <stdio.h>
extern int public_func(int x);
/* extern int helper(int x); ← 链接错误：helper 是 static */

int main(void) {
    printf("%d\n", public_func(10));  /* 输出 21 */
    return 0;
}

与 Python/Rust 对比

我的理解：C 把内存管理的权力交给程序员——这意味着更大的灵活性和性能，但也意味着更大的责任。Python/Rust 用各自的机制把这类错误消灭在摇篮里，C 则需要你自己做安全检查。

故障排查（FAQ）

Q: 什么时候该用 static 局部变量？

当你希望在函数调用间保持状态，但又不想让外部直接访问这个变量时。典型场景：计数器、缓存、单例模式。但注意：static 局部变量不是线程安全的。

Q: 全局变量和 static 文件级变量有什么区别？

我的建议：尽量用 static 限制全局变量的可见性，只在确实需要跨文件共享时才用 extern。

Q: free() 后为什么还要 p = NULL？

free(p) 只释放了 p 指向的内存，但 p 变量本身仍然保存着那个地址。如果不置 NULL，p 就变成了悬垂指针，下次不小心 *p 写入或读取就触发 undefined behavior。置 NULL 后，*p 会立即触发段错误（crash），这比"静默损坏内存，在很后面才暴露出来"好调试得多。

Q: 可以返回 const char * 字面量吗？

const char *get_name(void) {
    return "hello";  /* ✅ 安全！字符串字面量存储在 .rodata 段 */
}

字符串字面量（"hello"）存储在只读数据段（.rodata），生命周期 = 整个程序。所以返回它完全安全。但返回指向栈上局部变量的指针就不行。

知识扩展（选学）

C 标准的作用域规则

C11/C17 定义了四种作用域：

1. 块作用域（Block scope）：从声明处到包含它的 { } 结束
2. 函数作用域（Function scope）：仅适用于 goto 标签（整个函数内）
3. 文件作用域（File scope）：从声明处到文件结尾
4. 原型作用域（Prototype scope）：函数原型中的参数名，仅在原型中有效

TLS（Thread-Local Storage）C11 新增

_Thread_local 关键字：每个线程有自己的副本：

#include <threads.h>

_Thread_local int thread_counter = 0;
/* 每个线程有自己的 thread_counter，互不影响 */

register 关键字（过时）

C99 前曾用 register int x 建议编译器把变量放寄存器，但现代编译器比人更擅长寄存器分配。C17 中 register 已标记过期，仅作兼容性保留。

小结

祝贺！你已经掌握了 C 语言的作用域与生命周期。让我总结一下——

• 块作用域：{ } 创建新作用域，变量在离块时销毁
• 变量遮蔽：内层可以重复定义同名变量（但不推荐）
• static 局部变量：生命周期 = 整个程序，作用域 = 当前函数
• static 文件级：内部链接，防止跨文件暴露
• extern：声明在其他文件中定义的全局变量/函数
• 返回局部变量地址 = 未定义行为 → 用 static、malloc 或调用者分配
• 悬垂指针：指向已销毁内存的指针 → 永远不要持有
• Use-After-Free：free() 后继续使用 → free 后立即 p = NULL
• 字符串字面量安全返回 → 存储在 .rodata 段

我的理解：C 的作用域规则可以浓缩成一句话——变量在哪里声明，就在哪里可见；变量在哪里创建，就在哪里销毁。理解了这个原则，90% 的内存安全问题都可以提前预见。

术语表

延伸阅读

• cppreference: Scope and Linkage (C)
• cppreference: Lifetime (C)
• Beej's Guide to C: Static and Global Variables
• K&R《C 程序设计语言》第 4.4、4.5 章

继续学习

你现在已经理解了 C 语言中变量的"生死循环"。在后续章节中，我们将进入更高级的话题——动态内存管理，学习如何精准控制堆上每一块内存的分配与释放。

💡 提示：检查你的代码里所有返回指针的函数，确保没有返回局部变量的地址。如果使用了 malloc，确认每条路径都有对应的 free。

← 上一章：枚举与联合体 | 下一章 →

内存管理（Memory Management: malloc/free）

"C 语言不替你保管任何东西——它给你钥匙，但不帮你锁门。" —— 我发现

开篇故事

想象你在一家共享办公空间租了一个工位。你向管理员申请（malloc）了一个位置，坐下工作，使用这张桌子。

关键是：你用完之后必须归还（free）。如果你忘了退租，那张桌子就永远被占着。下一位同事来时，管理员告诉他「没有空位了」——不是因为真的没有，而是有人占了不退。

这就是 C 语言中的内存管理。malloc 是你申请空间，free 是你归还空间。每一次申请都对应一次归还，否则内存就像那些占着不走的工位，迟早会用完。

本章适合谁

• 已经写过 C 代码，但 malloc/free 总是手忙脚乱的人
• 在 Python/Java 等自动管理内存的语言里长大的开发者，想理解 C 的手动管理
• 遇到过程序占用内存越来越大，怀疑"内存泄漏"的人
• 被段错误（Segmentation fault）折磨，想知道"为什么不能解引用那个指针"的人

你会学到什么

• malloc、calloc、realloc、free 四个函数的正确用法
• **堆（Heap）与栈（Stack）**的本质区别，ASCII 内存布局图
• 三种常见分配模式：单个变量、数组、结构体
• 为什么 malloc 的返回值必须检查 NULL
• 三种致命错误：内存泄漏（Memory Leak）、悬垂指针（Dangling Pointer）、使用已释放内存（Use-After-Free）
• 用 valgrind 检测内存泄漏的基本流程
• 安全分配模式：每次 malloc 都配对 free，每次解引用前都检查 NULL

前置要求

• 理解 C 语言作用域与生命周期（已完成「作用域」章节）
• 掌握指针基本概念（* 解引用、& 取地址、NULL 检查）
• 了解 sizeof 运算符——它决定 malloc 分配多少字节

第一个例子：malloc 与 free 配对

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

int main(void) {
    /* 1. 分配：向操作系统申请 sizeof(int32_t) 字节 */
    int32_t *p = malloc(sizeof(int32_t));

    /* 2. 安全检查：malloc 可能失败，返回 NULL */
    if (p == NULL) {
        fprintf(stderr, "Error: malloc failed!\n");
        return 1;
    }

    /* 3. 使用：写入、读取 */
    *p = 42;
    printf("value = %" PRId32 "\n", *p);  /* 42 */

    /* 4. 释放：归还给操作系统 */
    free(p);
    p = NULL;  /* 防止悬垂指针 */

    return 0;
}

四步走：分配 → 检查 → 使用 → 释放 + 置 NULL。

原理解析

1. 堆 vs 栈：ASCII 内存布局

C 程序运行时的内存分为两个主要区域：

                    高地址
┌──────────────────────────────┐
│   栈 (Stack)                 │  ← 自动生长方向：高地址 → 低地址
│   ┌──────────────────────┐   │
│   │  main 的局部变量       │   │     int x = 10;     ← 栈变量
│   │  x = 10               │   │     char buf[64];   ← 栈数组
│   ├──────────────────────┤   │
│   │  func() 的局部变量     │   │     int y;          ← 函数调用时压入
│   │  y = 20               │   │
│   └──────────────────────┘   │     ← 函数返回时弹出，自动释放
├──────────────────────────────┤
│                              │     空洞（未使用）
│         ~~~~~~~~~~~~~~~       │
│                              │
├──────────────────────────────┤
│   堆 (Heap)                  │  ←  malloc 分配区域
│   ┌──────────────────────┐   │
│   │  malloc(4) → p1      │   │     int *p = malloc(sizeof(int));
│   │  malloc(256) → buf   │   │     char *b = malloc(256);
│   └──────────────────────┘   │     ← free(p) 后归还
├──────────────────────────────┤
│   数据段 (.data / .bss)      │     全局变量、static 变量
├──────────────────────────────┤
│   代码段 (.text)             │     程序指令
└──────────────────────────────┘
                    低地址

我的理解：栈是"自动门"——你走进来（进入作用域），门就开；你走出去，门就关（变量销毁）。堆是"租房子"——用 malloc 拿钥匙开门，用 free 退租还钥匙，不退就永远占着。

2. malloc：最基本的动态分配

#include <stdlib.h>

void *malloc(size_t size);

• 参数：需要分配的字节数
• 返回值：void*（任意类型指针），失败时返回 NULL
• 特点：分配的内存未初始化（内容是垃圾值）

int32_t *p = malloc(sizeof(int32_t));   /* 分配 4 字节 */
if (p == NULL) { /* 处理错误 */ }
*p = 42;                                /* 必须先赋值再读取 */

3. calloc：清零分配

void *calloc(size_t count, size_t size);

• 参数：元素数量 × 每个元素大小
• 返回值：同 malloc，失败返回 NULL
• 特点：分配的内存全部初始化为 0

int32_t *arr = calloc(100, sizeof(int32_t));  /* 100 个 int32_t，全为 0 */
if (arr == NULL) { /* 处理错误 */ }
/* arr[0] ... arr[99] 都是 0，不需要手动初始化 */

malloc vs calloc 对比：

4. realloc：调整已有分配的大小

void *realloc(void *ptr, size_t new_size);

• 参数：原指针（由 malloc/calloc/realloc 返回） + 新大小
• 返回值：新地址（可能与原址相同或不同），失败返回 NULL（原内存未释放）
• 特点：缩小不丢数据；增长时可能搬数据

int32_t *buf = malloc(10 * sizeof(int32_t));
/* ... 使用 buf[0]..buf[9] ... */

/* 需要更多空间 */
int32_t *tmp = realloc(buf, 20 * sizeof(int32_t));
if (tmp == NULL) {
    /* realloc 失败！buf 仍然有效，先 free(buf) 再退出 */
    free(buf);
    return 1;
}
buf = tmp;  /* 更新指针（realloc 可能搬了数据） */
/* 现在可以使用 buf[0]..buf[19]，前 10 个值保留 */

关键教训：realloc 的返回值必须用临时变量保存，永远不要 ptr = realloc(ptr, ...)——如果失败，ptr 变成 NULL，原内存地址丢失，造成泄漏。

5. free：释放内存

void free(void *ptr);

• 参数：malloc/calloc/realloc 返回的指针（或 NULL——对 NULL 调用 free 是安全的）
• 注意：
  • 释放后指针不会自动变 NULL——你必须手动 ptr = NULL
  • 对同一指针调用 两次 free = undefined behavior（double-free，严重错误）

6. 内存生命周期

┌─── malloc ────┐    ┌─── free ────┐
│               │    │             │
v               v    v             v
NULL ──→ 有效内存 ──→ 已释放(悬垂) ──→ NULL
         (可读写)    (不可再访问!)

生命周期三阶段：
1. 未分配：ptr == NULL
2. 已分配：ptr != NULL，可以读写 *ptr 或 ptr[i]
3. 已释放：free 后，ptr 成为悬垂指针，必须 ptr = NULL

常见分配模式

模式 1：单个变量分配

int32_t *p = malloc(sizeof(int32_t));
if (p == NULL) return;
*p = 99;
printf("%" PRId32 "\n", *p);
free(p); p = NULL;

模式 2：数组分配

size_t n = 10;
int32_t *arr = calloc(n, sizeof(int32_t));
if (arr == NULL) return;
for (size_t i = 0; i < n; i++) {
    arr[i] = (int32_t)(i * 2);
}
free(arr); arr = NULL;

模式 3：结构体分配

typedef struct {
    char name[32];
    int32_t age;
} Person;

Person *p = malloc(sizeof(Person));
if (p == NULL) return;
strncpy(p->name, "Alice", sizeof(p->name) - 1);
p->name[sizeof(p->name) - 1] = '\0';
p->age = 25;
printf("name=%s, age=%" PRId32 "\n", p->name, p->age);
free(p); p = NULL;

常见错误（Error-First）

❌ 错误 1：malloc 后忘记 free —— 内存泄漏（Memory Leak）

/* ❌ 泄漏示例 */
void leaky_function(void) {
    char *buf = malloc(256);
    if (buf == NULL) return;
    strncpy(buf, "important data", 255);
    buf[255] = '\0';
    /* ... 使用 buf ... */
    /* 忘记 free(buf)！ */
    /* buf 离开作用域，但堆内存没有归还 → 泄漏 */
}
/* 每次调用这个函数，泄漏 256 字节 */

valgrind 检测报告：

==12345== 256 bytes in 1 blocks are definitely lost
==12345==    at malloc() → leaky_function()

✅ 修复：每条执行路径都必须有 free：

/* ✅ 正确示例 */
void safe_function(void) {
    char *buf = malloc(256);
    if (buf == NULL) return;
    strncpy(buf, "important data", 255);
    buf[255] = '\0';
    /* ... 使用 buf ... */
    free(buf);
    buf = NULL;  /* 防止悬垂 */
}

❌ 错误 2：malloc 返回 NULL 时解引用 —— 段错误

/* ❌ 没有检查 NULL */
int32_t *p = malloc(sizeof(int32_t));
*p = 42;       /* ❌ 如果 malloc 失败 → 对 NULL 解引用 → Segmentation fault */

✅ 修复：永远在使用前检查：

/* ✅ 安全检查 */
int32_t *p = malloc(sizeof(int32_t));
if (p == NULL) {
    fprintf(stderr, "Error: not enough memory\n");
    return;
}
*p = 42;       /* ✅ 安全 */

❌ 错误 3：Use-After-Free（使用已释放内存）

/* ❌ 先释放，后使用 */
int32_t *p = malloc(sizeof(int32_t));
*p = 42;
free(p);
printf("%d\n", *p);  /* ❌ UB: 读取已释放的内存 */
*p = 100;            /* ❌ UB: 写入已释放的内存 */

✅ 修复：释放后立即置 NULL：

free(p);
p = NULL;
/* printf("%d\n", *p); → 现在会立刻崩溃（段错误），比静默损坏易调试 */

❌ 错误 4：悬垂指针（Dangling Pointer）

/* ❌ 指向局部变量的指针 */
int32_t *get_local(void) {
    int x = 42;
    return &x;  /* ❌ x 是栈变量，函数返回后 x 不存在 */
}
int32_t *p = get_local();
printf("%" PRId32 "\n", *p);  /* ❌ p 是悬垂指针 → UB */

✅ 修复：三种方案——

/* 方案 A：返回堆分配 */
int32_t *safe_a(void) {
    int32_t *x = malloc(sizeof(int32_t));
    if (x) *x = 42;
    return x;
}
/* 调用者负责 free */

/* 方案 B：让调用者分配 */
void safe_b(int32_t *result) {
    *result = 42;
}
/* 调用方: int32_t val; safe_b(&val); */

/* 方案 C：用 static（但非线程安全） */
int32_t *safe_c(void) {
    static int x = 42;
    return &x;
}

❌ 错误 5：realloc 没有用临时变量

/* ❌ 如果 realloc 失败，原指针丢失 */
int32_t *buf = malloc(100);
buf = realloc(buf, 200);  /* 失败: buf = NULL, 原 100 字节泄漏 */

✅ 修复：

int32_t *buf = malloc(100);
if (buf == NULL) return;

int32_t *tmp = realloc(buf, 200);
if (tmp == NULL) {
    free(buf);  /* 保留的 100 字节仍然安全，手动释放 */
    return;
}
buf = tmp;      /* 成功: 更新指针 */

动手练习

🟢 练习 1：malloc + free 配对

写一个函数 print_sum()，用 malloc 分配两个 int32_t，赋值为 10 和 20，打印它们的和，然后正确 free。

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

void print_sum(void) {
    int32_t *a = malloc(sizeof(int32_t));
    int32_t *b = malloc(sizeof(int32_t));
    if (a == NULL || b == NULL) {
        free(a);
        free(b);
        fprintf(stderr, "malloc failed\n");
        return;
    }

    *a = 10;
    *b = 20;
    printf("sum = %" PRId32 "\n", *a + *b);

    free(a); a = NULL;
    free(b); b = NULL;
}

🟡 练习 2：realloc 动态增长

初始化一个 int32_t 数组（3 个元素），填入 10, 20, 30。用 realloc 扩展到 6 个元素，追加 40, 50, 60，打印所有元素。

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

void grow_array_demo(void) {
    int32_t *arr = malloc(3 * sizeof(int32_t));
    if (arr == NULL) return;
    arr[0] = 10; arr[1] = 20; arr[2] = 30;

    int32_t *tmp = realloc(arr, 6 * sizeof(int32_t));
    if (tmp == NULL) {
        free(arr);
        fprintf(stderr, "realloc failed\n");
        return;
    }
    arr = tmp;
    arr[3] = 40; arr[4] = 50; arr[5] = 60;

    for (int32_t i = 0; i < 6; i++) {
        printf("arr[%" PRId32 "] = %" PRId32 "\n", i, arr[i]);
    }
    free(arr); arr = NULL;
}

🔴 练习 3：安全分配模式（完整防御）

写一个函数 create_person(const char *name, int32_t age)，返回一个堆分配的 Person 结构体。必须满足：

1. malloc 返回值检查 NULL
2. strncpy 安全复制字符串（非 strcpy）
3. 调用方负责 free，且有 free 代码

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

typedef struct {
    char name[32];
    int32_t age;
} Person;

Person *create_person(const char *name, int32_t age) {
    Person *p = malloc(sizeof(Person));
    if (p == NULL) return NULL;

    strncpy(p->name, name, sizeof(p->name) - 1);
    p->name[sizeof(p->name) - 1] = '\0';
    p->age = age;
    return p;
}

int main(void) {
    Person *p = create_person("Bob", 30);
    if (p == NULL) {
        fprintf(stderr, "create_person failed\n");
        return 1;
    }
    printf("name=%s, age=%" PRId32 "\n", p->name, p->age);
    free(p);
    p = NULL;
    return 0;
}

故障排查（FAQ）

Q：什么时候应该用 malloc 而不是栈变量？

当你需要以下能力时：

• 跨函数使用：数据在函数返回后仍然有效（栈变量会在函数返回时销毁）
• 大数组：几个 MB 的数组放在栈上会栈溢出（通常栈只有几 MB），malloc 用堆空间
• 动态大小：在运行时才知道需要多大空间

/* ❌ 栈上大数组 → 可能栈溢出 */
double big_array[1000000];  /* 8 MB! 通常栈只有 8 MB */

/* ✅ 堆上大数组 */
double *big_array = malloc(1000000 * sizeof(double));
/* ... */
free(big_array);

Q：free(NULL) 安全吗？

是的！C 标准规定：free(NULL) 是一个 no-op（什么都不做）。你可以放心地写：

free(p);  /* 即使 p 是 NULL 也安全 */
p = NULL;

Q：什么是 valgrind？怎么用？

valgrind 是一个 C 内存调试工具。安装后，这样使用：

# 编译时保留调试信息（-g）
gcc -g -Wall -Wextra -std=c17 -o myprogram myprogram.c

# 用 valgrind 运行
valgrind --leak-check=full ./myprogram

输出示例：

==12345== HEAP SUMMARY:
==12345==     in use at exit: 0 bytes in 0 blocks
==12345==   total heap usage: 5 allocs, 5 frees, 1,234 bytes allocated
==12345==
==12345== All heap blocks were freed -- no leaks are possible

如果看到 in use at exit: 0 bytes，恭喜你，你的代码 valgrind 清洁！

Q：malloc 和 calloc 性能差多少？

calloc 需要把内存清零，所以比 malloc 稍慢。但差距通常很小（现代操作系统有优化）。如果你本来就要把内存清零（例如初始化计数器），calloc 可能更快——因为操作系统级别的 zero-page 填充比你自己用 memset 快。

Q：可以多次 free 同一个指针吗？

绝对不行。第二次 free 同一个非 NULL 指针 = double-free = undefined behavior（通常崩溃或安全漏洞）。这也是为什么 free 后立即 p = NULL 很重要。

与 Python 对比：自动 vs 手动内存管理

我的理解：Python 像一个贴心的保姆，自动帮你收拾玩具（释放内存）。C 像一个严格的工具——它不帮你收拾，但你可以精确控制每一个字节的去向。哪种更好取决于场景：游戏引擎需要 C 的精确控制，而 web 后端可以用 Python 的便利。

知识扩展（选学）

malloc 的底层原理：sbrk 和 mmap

在 Linux 上，malloc 的底层实现依赖两个系统调用：

• 小分配（一般 < 128KB）：通过 sbrk() 扩展程序的数据段（brk）
• 大分配（≥ 128KB）：通过 mmap() 创建新的内存映射区域

         sbrk 增长方向 →
┌─────────────────┐  ┌──────┐  ┌──────┐
│    brk (堆)      │  │ mmap │  │ mmap │
│  malloc 的小块    │  │ 大文件 │  │ 大数据 │
└─────────────────┘  └──────┘  └──────┘

内存对齐（Alignment）

malloc 返回的地址总是对齐到 8 字节或 16 字节——无论你要多少。这是因为现代 CPU 访问对齐内存比非对齐内存快得多。

char *a = malloc(1);   /* 分配 1 字节，实际可能占用 8/16 字节 */
char *b = malloc(1);   /* malloc 返回的地址间隔 ≥ alignment */

内存池（Memory Pool）

频繁 malloc/free 小块内存会导致碎片化。高性能程序常用"内存池"——一次性分配一大块，然后自己管理内部的小块分配：

/* 简化版内存池示意 */
#define POOL_SIZE (1024 * 1024)  /* 1 MB */
static char pool[POOL_SIZE];
static size_t pool_offset = 0;

void *pool_alloc(size_t size) {
    if (pool_offset + size > POOL_SIZE) return NULL;
    void *p = &pool[pool_offset];
    pool_offset += size;
    return p;
}
/* 一次 pool_free 释放所有（简化版无单个 free） */

小结

恭喜你闯过了 C 语言最棘手的章节——内存管理。让我总结核心要点——

• 四步走原则：malloc → 检查 NULL → 使用 → free + p = NULL
• malloc vs calloc vs realloc：基本分配、清零分配、调整大小
• 安全 realloc：永远用临时变量保存返回值
• 三大致命错误：内存泄漏（忘记 free）、悬垂指针（指向已销毁内存）、Use-After-Free（free 后继续使用）
• valgrind：你的 C 记忆守护神——每次写 C 程序都跑一遍
• 堆 vs 栈：栈是自动门（作用域控制），堆是租房子（你控制）

我的教训是：C 语言的内存管理就像骑自行车——开始觉得可怕，但一旦学会，你会获得其他地方学不到的「自由感」。关键就是两个字：配对。每一笔 malloc 都要有对应的一笔 free，清清楚楚，一笔不漏。

术语表

延伸阅读

• cppreference: Dynamic memory allocation (C) — C 标准库的 malloc/free 参考
• Valgrind 官方文档 — 快速上手指南
• Beej's Guide to C: Dynamic Memory — 图解 malloc/free
• K&R《C 程序设计语言》第 8.7 章 — malloc 的经典描述
• Memory Safety in C — OWASP 安全备忘录

继续学习

你现在已经掌握了 C 语言中最核心的能力——手动内存管理。这是 C 的强大之处，也是它可怕的原因。

在下一章节中，我们将学习如何编写更复杂的程序结构：文件输入输出，学会读写文件、处理错误、以及缓冲区管理的进阶技巧。

💡 提示：检查你写过的所有使用 malloc 的代码——每个是否都有 free？每个 malloc 返回值是否都检查了 NULL？每次 free 后是否都 ptr = NULL？

← 上一章：作用域与生命周期 | 下一章 → 文件 I/O

函数指针 (Function Pointers)

开篇故事

想象你有一台电视遥控器。遥控器上的每一个按钮，并不「包含」换台的功能——它们只是指向电视内部不同的信号处理电路。按下「频道+」，遥控器告诉你：「去调那个函数」。

函数指针就是 C 语言里的遥控器按钮。它不保存代码本身，它保存的是代码的地址。当你通过函数指针调用时，程序跳转到那个地址去执行。就像遥控器指向电视内部的电路，函数指针指向程序的「入口」。

本章适合谁

• 已经理解普通指针（int *p、char *s）的基本概念
• 学过函数声明和调用，但对函数名是什么还不清楚
• 想理解「第一等函数」在 C 中如何模拟
• 被 int (*fp)(int) 和 int *fp(int) 搞混淆的初学者

你会学到什么

1. 函数指针的语法——return_type (*name)(param_types) 到底怎么读
2. 函数指针与函数名的关系——为什么 func 和 &func 等价
3. 函数指针数组（Dispatch Table / 分派表）
4. 将函数指针作为参数传递（C 语言中的「高阶函数」）
5. 将函数指针嵌入结构体（C 语言模拟 OOP 方法）
6. typedef 让函数指针可读——避免灾难性语法

前置要求

• 完成 函数 章节
• 完成 指针基础 章节
• 理解类型（type）、声明（declaration）、定义（definition）的概念

第一个例子

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

int32_t add(int32_t a, int32_t b) {
    return a + b;
}

int main(void) {
    /* 声明一个函数指针: 指向 "返回 int32_t、接受两个 int32_t 参数" 的函数 */
    int32_t (*fp)(int32_t, int32_t) = &add;

    /* 通过指针调用函数 */
    int32_t result = fp(3, 5);  /* 等价于 add(3, 5) */
    printf("fp(3, 5) = %" PRId32 "\n", result);

    /* 也可以不用 &——函数名 decay 为指针 */
    fp = add;
    result = (*fp)(10, 20);  /* 显式解引用调用 */
    printf("(*fp)(10, 20) = %" PRId32 "\n", result);

    return 0;
}

输出：

fp(3, 5) = 8
(*fp)(10, 20) = 30

分步解析

1. int32_t (*fp)(int32_t, int32_t) — 声明 fp 是一个函数指针
2. = &add — 把 add 函数的地址赋给 fp（& 可以省略）
3. fp(3, 5) — 通过指针调用函数，等价于 add(3, 5)

原理解析

1. 函数指针语法：怎么读？

C 的声明语法是「顺时针螺旋规则」（Clockwise/Spiral Rule）。从变量名开始，向外螺旋阅读：

          ┌─ param types: (int32_t, int32_t)
          │
int32_t (*fp)(int32_t, int32_t)
  │  │    │
  │  │    └── fp is a
  │  └────── pointer to
  └───────── function returning int32_t

读出来就是：「fp 是一个指针，指向一个函数，该函数接受两个 int32_t 参数，返回 int32_t。」

对比迷惑性写法：

int32_t *fp(int32_t, int32_t);   /* ❌ 这是函数声明！fp 返回 int32_t* */
int32_t (*fp)(int32_t, int32_t); /* ✅ 这才是函数指针 */

括号的优先级决定了一切。

2. 函数名 vs. 函数地址

在 C 语言中，函数名本身就是一个「衰减为指针」的值：

int32_t add(int32_t a, int32_t b) { return a + b; }

/* 以下四种写法完全等价 */
int32_t (*fp1)(int32_t, int32_t) = add;    /* 函数名 decay */
int32_t (*fp2)(int32_t, int32_t) = &add;   /* 显式取地址 */
fp1(3, 5);        /* 隐式解引用调用 */
(*fp1)(3, 5);     /* 显式解引用调用 */

这类似于数组名 decay 为 &arr[0]。但建议统一用 &func 取地址 + 隐式调用风格，语义最清晰。

3. ASCII 内存示意图：函数指针存的是什么？

函数指针存储的是可执行代码的内存地址（代码段 / text segment）：

内存地址空间:
┌─────────────────────────────────────────┐
│  .text (代码段)                          │
│                                         │
│  0x00401000 │ add():          ← fp 指向这里 │
│             │   push rbp      │              │
│             │   mov eax, edi  │              │
│             │   add eax, esi  │              │
│             │   pop rbp       │              │
│             │   ret           │              │
│  0x00401010 │ sub():          │              │
│             │   ...           │              │
├─────────────────────────────────────────┤
│  .data / .bss (栈/数据段)                │
│                                         │
│  fp (在栈上): 0x00401000 ←───────────────┘
│  (8 bytes on 64-bit)                    │
└─────────────────────────────────────────┘

4. 函数指针数组（Dispatch Table）

函数指针可以组成数组，实现简单的「分派表」模式：

typedef int32_t (*binary_op_t)(int32_t, int32_t);

int32_t add(int32_t a, int32_t b) { return a + b; }
int32_t sub(int32_t a, int32_t b) { return a - b; }
int32_t mul(int32_t a, int32_t b) { return a * b; }

static const binary_op_t ops[] = { add, sub, mul };

/* ops[0](3, 5) → add(3, 5) → 8 */
/* ops[1](10, 3) → sub(10, 3) → 7 */

5. 函数指针作为参数（高阶函数）

把函数指针传给另一个函数，就是 C 中的「高阶函数」：

/* apply 接受一个二元操作函数指针 */
int32_t apply(int32_t a, int32_t b, int32_t (*op)(int32_t, int32_t)) {
    return op(a, b);  /* 调用传入的函数 */
}

printf("%d\n", apply(3, 5, add));  /* 8 */
printf("%d\n", apply(10, 3, sub)); /* 7 */

6. Struct + 函数指针（模拟 OOP 方法）

C 没有类和方法，但可以用结构体 + 函数指针模拟：

typedef struct {
    double x, y;
    double (*length)(const struct Point2D *);  /* 方法 */
} Point2D;

static double point_length(const Point2D *p) {
    return sqrt(p->x * p->x + p->y * p->y);
}

Point2D pt = { .x = 3.0, .y = 4.0, .length = point_length };
printf("length = %.1f\n", pt.length(&pt));  /* 5.0 */

Python / JavaScript 对比

C 函数指针的优势是零开销——它就是一个 8 字节的函数地址，没有任何运行时包装。劣势是不支持闭包（无法捕获外部变量），除非配合 void* user_data 传参。

常见错误

❌ 错误 1：括号优先级搞错

/* ❌ 声明了一个返回 int* 的函数，不是函数指针！ */
int *fp(int);

/* ✅ 正确的函数指针声明 */
int (*fp)(int);

编译器报错：

warning: incompatible pointer types initializing 'int *(int)' (aka ...) with &func

修复：加上括号确保 *fp 先绑定：

int (*fp)(int) = &func;  /* ✅ fp 是指针，指向函数 */

❌ 错误 2：函数指针类型不匹配

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

/* ❌ 指针类型不匹配：返回 double vs 返回 int */
double (*fp)(int, int) = add;  /* 编译警告/错误！ */

修复：用 typedef 明确类型，避免手写错误：

typedef int (*binary_add_t)(int, int);
binary_add_t fp = add;  /* ✅ 类型一致 */

❌ 错误 3：解引用语法错误

int32_t (*fp)(int32_t) = □

/* ❌ 优先级错误：*(fp(3)) 先调用 fp(3)，再解引用返回值 */
int32_t result = *(fp(3));

/* ✅ 两种都是正确的 */
int32_t result1 = fp(3);       /* 隐式解引用 */
int32_t result2 = (*fp)(3);    /* 显式解引用 */

动手练习

🟢 入门：声明并使用函数指针

定义 int32_t multiply(int32_t a, int32_t b)，用函数指针调用它。

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

int32_t multiply(int32_t a, int32_t b) {
    return a * b;
}

int main(void) {
    int32_t (*fp)(int32_t, int32_t) = &multiply;
    printf("6 × 7 = %" PRId32 "\n", fp(6, 7));
    return 0;
}

🟡 中级：函数指针数组实现简易计算器

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

int32_t add(int32_t a, int32_t b) { return a + b; }
int32_t sub(int32_t a, int32_t b) { return a - b; }
int32_t mul(int32_t a, int32_t b) { return a * b; }

typedef int32_t (*op_func_t)(int32_t, int32_t);

int main(void) {
    const op_func_t ops[3] = { add, sub, mul };
    const char *names[3] = { "+", "-", "*" };

    int32_t x = 10, y = 3;
    for (int32_t i = 0; i < 3; i++) {
        printf("%d %s %d = %" PRId32 "\n",
               (int)x, names[i], (int)y, ops[i](x, y));
    }
    return 0;
}

🔴 挑战：用 typedef 简化复杂函数指针

声明一个函数指针：指向 void (*)(const char *, int)，即「接受 const char* 和 int，返回 void」的函数。

#include <stdio.h>

void logger(const char *msg, int level) {
    printf("[%d] %s\n", level, msg);
}

/* typedef 简化 */
typedef void (*log_callback_t)(const char *, int);

int main(void) {
    log_callback_t cb = logger;
    cb("hello", 1);
    return 0;
}

故障排查 (FAQ)

Q：fp(3, 5) 和 (*fp)(3, 5) 有什么区别？

A：没有区别。C 标准规定函数指针调用时自动解引用，两者完全等价。我推荐 fp(3, 5) 更简洁。

Q：为什么不用 typedef 每次都想死？

A：这正是我推荐的原因。函数指针类型签名极难手写，每次出错。typedef int32_t (*binary_op_t)(int32_t, int32_t) 让代码清晰得多。

Q：函数指针能指向 lambda / 匿名函数吗？

A：C17 不支持 lambda。GCC 扩展有嵌套函数和 lambda 表达式，但不可移植。如果需要闭包，用 void* user_data + 函数指针组合。

Q：函数指针的大小是多少？

A：与数据指针相同——32 位平台 4 字节，64 位平台 8 字节。sizeof(fp) 即可验证。

知识扩展 (选学)

函数指针强制转换

C 允许将函数指针转换为 void*（非标准但广泛支持），用于动态加载库：

/* 不推荐但在 dlfcn.h 中常见 */
void *handle = dlopen("libfoo.so", RTLD_LAZY);
void *sym = dlsym(handle, "my_function");
/* 必须 cast 回正确的函数指针类型才能调用 */
typedef int (*func_t)(int);
func_t f = (func_t)sym;

Function Pointer vs. Virtual Function (C++)

C++ 的虚函数表（vtable）本质上就是一张函数指针数组。C 结构体 + 函数指针是手动实现 vtable 的方式：

vtable (C++ 编译器自动生成):
┌──────────────────┐
│  vtable ptr ──→  │  Draw()     → Circle::Draw
│                  │  Resize()   → Circle::Resize
└──────────────────┘

用 C 结构体手动实现的就是本章第 6 个模式。

Python Callable 对比表

小结

• 函数指针存储的是函数的入口地址，指向可执行代码
• 语法核心：return_type (*name)(param_types) — 括号改变优先级
• func 和 &func 等价（函数名 decay 为函数指针）
• fp(args) 和 (*fp)(args) 等价（调用时自动解引用）
• 函数指针数组实现分派表（dispatch table）
• 函数指针作参数 = C 的高阶函数模式
• 结构体 + 函数指针 = C 模拟 OOP 方法的基石
• 始终用 typedef 给函数指针类型命名，避免语法灾难

术语表

延伸阅读

• cppreference: Function pointers
• The C Declarator Syntax — Clockwise/Spiral Rule
• K&R《C 程序设计语言》§5.8 — 函数指针

选择建议：先理解语法再深入——cppreference 是权威参考，K&R 的解释更直觉。

继续学习

函数指针是回调函数的基础。掌握了函数指针的语法，下一章我们将学习如何用函数指针实现回调模式和模拟多态——这是 C 语言事件驱动和面向对象的根基。

• 上一章：函数基础
• 下一章：回调函数与多态

回调函数与多态 (Callbacks & Polymorphism)

开篇故事

想象你点了一份外卖。你留下手机号，然后去做别的事。厨师做好了之后会回电给你——你不需要站在柜台干等。

这就是回调（Callback）：你把一个「联系方式」（函数指针）交给别人，等对方完成任务后主动调用它。qsort 把比较函数当回调、GUI 框架把 onClick 当回调、网络库把数据到达通知当回调——核心道理完全一样：你不用等，对方会来找你。

函数指针的真正力量不在于「调用一个已知函数」，而在于把函数交给别人去调用。

本章适合谁

• 已经掌握 函数指针 的基本语法
• 用过 qsort 但想理解它为什么需要回调函数
• 好奇 C 语言如何实现面向对象的多态效果
• 想在 C 中实现事件驱动 / 观察者模式的开发者

你会学到什么

1. 回调函数的本质：把函数指针作为参数传入
2. qsort 回调示例——标准库如何设计回调接口
3. void* 泛型数据传递——回调的通用参数模式
4. 函数指针表实现多态——手动 vtable
5. 事件驱动回调模拟——发布-订阅模式

前置要求

• 完成 函数指针 章节
• 理解 void*（无类型指针）的含义

第一个例子

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

/* 比较函数: 回调给 qsort 使用 */
int cmp_int(const void *a, const void *b)
{
    int ia = *(const int *)a;
    int ib = *(const int *)b;
    return (ia > ib) - (ia < ib);  /* 安全的三态比较 */
}

int main(void)
{
    int arr[] = { 5, 2, 8, 1, 9, 3 };
    size_t n = sizeof(arr) / sizeof(arr[0]);

    /* qsort 接受回调函数 */
    qsort(arr, n, sizeof(int), cmp_int);

    printf("排序后: ");
    for (size_t i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

输出：

排序后: 1 2 3 5 8 9

这就是回调——你把 cmp_int 函数传给 qsort，qsort 在内部需要比较两个元素时调用它。

原理解析

1. 回调函数（Callback）

回调的本质就是：函数 A 把函数指针传给函数 B，B 在需要时调用 A 的函数。

调用者 (Caller)          被调者 (Callee)
    │                       │
    │  apply(3, 5, my_add) │
    ├─────────────────────────►│
    │                       │  内部: op(a, b)
    │                       │  └► 调用 my_add(3, 5)
    │  ◄── 8 ────────────────┤
    │                       │

/* callee: 接受回调函数 */
int32_t compute(int32_t a, int32_t b, int32_t (*callback)(int32_t, int32_t))
{
    return callback(a, b);  /* 回调调用者的函数 */
}

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

printf("%d\n", compute(3, 5, add));  /* 8 */
printf("%d\n", compute(3, 5, mul));  /* 15 */

2. qsort 回调详解

C 标准库的 qsort 是回调的经典示例：

void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));

• base: 数组起始地址
• nmemb: 元素数量
• size: 每个元素的大小
• compar: 回调函数指针，比较两个元素

比较函数约定：

• 返回 < 0：a < b（a 排前面）
• 返回 0：a == b
• 返回 > 0：a > b（b 排前面）

3. void* 泛型数据传递

回调函数经常需要接收额外的用户数据。C 的模式是 void*：

/* 回调函数签名: 接受 void* 用户数据 */
typedef void (*visitor_t)(int32_t value, void *user_data);

/* 遍历数组并调用回调 */
void visit_array(const int32_t arr[], int32_t len,
                 visitor_t visit, void *user_data)
{
    for (int32_t i = 0; i < len; i++) {
        visit(arr[i], user_data);
    }
}

/* 回调实现: 统计总和 */
void sum_visitor(int32_t value, void *user_data)
{
    int32_t *sum = (int32_t *)user_data;
    *sum += value;
}

4. 函数指针表实现多态

C 没有虚拟函数，但可以用函数指针表模拟：

Python 多态              C 函数指针多态
─────────────────       ──────────────────────
class Shape:            struct Shape {
    def area(self): ...     double (*area)(Shape*);
                          }
class Circle(Shape):    struct Circle {
    def area(self): ...       Shape base;
                              double radius;
                          }

5. 事件驱动回调模拟

事件驱动模式：注册回调 → 事件触发 → 调用所有注册的回调

  ┌───────────┐     register(on_click)     ┌───────────┐
  │  Listener ├────────────────────────────►│  Emitter  │
  └───────────┘                              │           │
  ┌───────────┐     register(on_hover)       │  callbacks│
  │  Handler  ├────────────────────────────►│  [0]: on_ │
  └───────────┘         ...                  │       click│
                                            │  [1]: on_  │
                                             │       hover│
                                            └─────┬──────┘
                                                  │ emit("click")
                                            ┌─────▼──────┐
                                            │ 调用 callbacks│
                                            └────────────┘

Python / JavaScript 回调对比

C 回调的劣势：不支持闭包，无法捕获外部变量。必须通过 void* user_data 显式传递。 C 回调的优势：零开销，编译时类型安全，无需运行时虚拟机或垃圾回收。

常见错误

❌ 错误 1：回调函数签名不匹配

/* ❌ qsort 要求: int (*)(const void *, const void *) */
int cmp(int a, int b) { return a - b; }  /* 类型不对! */

qsort(arr, n, sizeof(int), cmp);  /* 编译警告! */

编译器报错：

warning: incompatible pointer types passing 'int (int, int)' to parameter
  of type 'int (*)(const void *, const void *)'

修复：使用正确的签名 + typedef：

typedef int (*comparator_t)(const void *, const void *);

int cmp_int(const void *a, const void *b)
{
    int ia = *(const int *)a;
    int ib = *(const int *)b;
    return (ia > ib) - (ia < ib);
}

comparator_t cmp = cmp_int;
qsort(arr, n, sizeof(int), cmp);  /* ✅ 正确 */

❌ 错误 2：用减法做三态比较（危险!）

/* ❌ 危险: 整数溢出可能导致错误结果 */
int cmp_bad(const void *a, const void *b)
{
    return *(int *)a - *(int *)b;  /* 如果 a=INT_MAX, b=-1, 溢出! */
}

修复：用分支安全的三态比较：

/* ✅ 安全 */
int cmp_good(const void *a, const void *b)
{
    int ia = *(const int *)a;
    int ib = *(const int *)b;
    return (ia > ib) - (ia < ib);
}

❌ 错误 3：忘记 void* 强转

/* ❌ C 中 void* 不能隐式解引用 */
int sum = *(void *)user_data;  /* 编译错误! */

/* ✅ 必须强转到具体类型 */
int sum = *(int *)user_data;

动手练习

🟢 入门：用 qsort 排序字符串数组

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

int cmp_str(const void *a, const void *b)
{
    return strcmp(*(const char **)a, *(const char **)b);
}

int main(void)
{
    const char *words[] = {"banana", "apple", "cherry", "date"};
    size_t n = sizeof(words) / sizeof(words[0]);

    qsort(words, n, sizeof(const char *), cmp_str);

    for (size_t i = 0; i < n; i++) {
        printf("%s\n", words[i]);
    }
    return 0;
}

🟡 中级：用 void* 实现泛型遍历器

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

typedef void (*element_visitor_t)(const void *elem, void *user_data);

void foreach(const void *arr, int32_t len, size_t elem_size,
             element_visitor_t visit, void *user_data)
{
    const char *p = (const char *)arr;
    for (int32_t i = 0; i < len; i++) {
        visit(p + i * elem_size, user_data);
    }
}

void print_elem(const void *elem, void *user_data)
{
    printf("%d ", *(const int *)elem);
}

void double_elem(const void *elem, void *user_data)
{
    int32_t *target = (int32_t *)elem;
    *target *= 2;
    int32_t *total = (int32_t *)user_data;
    *total += *target;
}

int main(void)
{
    int arr[] = { 1, 2, 3, 4, 5 };

    printf("原始: ");
    foreach(arr, 5, sizeof(int), print_elem, NULL);
    printf("\n");

    int32_t total = 0;
    foreach(arr, 5, sizeof(int), double_elem, &total);
    printf("翻倍后总和: %d\n", total);
    return 0;
}

🔴 挑战：实现简易观察者模式

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

#define MAX_OBSERVERS 8

typedef void (*observer_func_t)(int32_t event_code, void *user_data);

typedef struct {
    observer_func_t func;
    void *user_data;
} Observer;

typedef struct {
    Observer observers[MAX_OBSERVERS];
    int32_t count;
} EventManager;

void em_init(EventManager *em)
{
    em->count = 0;
}

int32_t em_register(EventManager *em, observer_func_t func,
                    void *user_data)
{
    if (em->count >= MAX_OBSERVERS) return -1;
    em->observers[em->count].func = func;
    em->observers[em->count].user_data = user_data;
    em->count++;
    return 0;
}

void em_notify(EventManager *em, int32_t event_code)
{
    for (int32_t i = 0; i < em->count; i++) {
        em->observers[i].func(event_code, em->observers[i].user_data);
    }
}

void on_click(int32_t code, void *data)
{
    printf("  [ClickHandler] received event %d\n", (int)code);
}

void on_log(int32_t code, void *data)
{
    printf("  [Logger] event %d logged\n", (int)code);
}

int main(void)
{
    EventManager em;
    em_init(&em);

    em_register(&em, on_click, NULL);
    em_register(&em, on_log, NULL);

    printf("触发 CLICK 事件:\n");
    em_notify(&em, 100);

    return 0;
}

故障排查 (FAQ)

Q：为什么 C 标准库回调都用 void*？不安全吗？

A：void* 是 C 实现泛型的唯一方式。它确实放弃了类型安全，但换来了通用性。调用时你必须手动 cast 到正确的类型——这就是「信任但验证」模式。

Q：回调函数能修改原始数据吗？

A：可以。如果回调接收的是 void*（不是 const void*），它可以修改指向的数据。qsort 的比较函数接收 const void* 因为它不应修改数组；我们的 foreach 接收 void* 因为它允许修改。

Q：C 没有闭包, 回调怎么捕获外部变量？

A：通过 void* user_data 参数手动传递。你需要把需要捕获的变量打包成 struct，然后把结构体指针传进去。这就是 C 的「闭包」。

知识扩展 (选学)

C++ lambda vs C void*

// C++: lambda + closure
int threshold = 50;
auto filter = [threshold](int x) { return x > threshold; };

// C 等价: 手动 struct 闭包
typedef struct { int threshold; } FilterCtx;
int filter_callback(int x, void *ud) {
    FilterCtx *ctx = (FilterCtx *)ud;
    return x > ctx->threshold;
}

链表遍历回调

typedef struct Node {
    int data;
    struct Node *next;
} Node;

void foreach_node(Node *head,
                  void (*visit)(int data, void *ud),
                  void *ud)
{
    for (Node *cur = head; cur != NULL; cur = cur->next) {
        visit(cur->data, ud);
    }
}

/* 使用: 求和 */
void sum_visit(int data, void *ud) {
    *(int *)ud += data;
}

Qt 的 Signal/Slot vs C 回调

Qt 的 Signal/Slot 本质上也是回调的变体——只是多了类型检查和连接管理。C 的函数指针回调是它的极简版。

小结

• 回调函数：把函数指针作为参数，由被调用方在需要时 invoke
• qsort 是最经典的回调：传入比较函数，由排序算法调用
• void* user_data 是 C 的泛型参数模式——手动 cast 到具体类型
• 函数指针表 = C 模拟 OO 多态的方式（手动 vtable）
• 事件管理器 = 用函数指针数组实现观察者模式
• C 回调不支持闭包，需手动传 void* 捕获状态
• 安全的三态比较：(a > b) - (a < b)，不是 a - b

术语表

延伸阅读

• cppreference: qsort — 标准库回调
• Beej's Guide: Callbacks
• Design Patterns: Observer

选择建议：先用 qsort 熟悉回调，再尝试自己实现事件管理器。

继续学习

回调是 C 语言事件驱动和面向对象的基石。掌握了回调模式后，你可以：

• 深入 Advance 章节，学习更复杂的 C 设计模式

• 尝试用 C 实现链表、树等数据结构中的回调遍历

• 阅读开源项目中 event loop / reactor 模式的实现

• 上一章：函数指针

• 下一章：进阶主题

void* 泛型编程 (Generic Programming with void*)

开篇故事

想象一个万能充电适配器。它能插进美标、欧标、英标的插座——因为它的插头是通用的。但当你把数据线连到设备上时，你必须知道那台设备需要多少伏特。适配器不替你操心，你得自己确认。

void* 就是 C 的万能适配器。它可以指向任何类型的数据（int、double、struct……），但在读取之前你必须把它转回正确的类型。适配器能接任何插头，但接错了电压设备就烧了。void* 能存任何地址，但转错了类型数据就乱了。

灵活性很高，责任也在你。

本章适合谁

• 学过指针基础, 能理解 int*、char* 的概念
• 对"泛型"、"多态"这些词好奇的 C 初学者
• 用过 Python/JavaScript 等动态类型语言, 想了解 C 的"类型擦除"
• 正在读标准库函数（如 qsort、bsearch）源码的人

你会学到什么

1. void* 是什么 —— 无类型指针的核心语义
2. 如何安全地将 void* 转回具体类型
3. void* 在函数参数中的泛型用法
4. 基于宏的泛型容器技巧
5. C11 _Generic 类型选择表达式
6. void* 的局限性与 C++/Rust 泛型对比

前置要求

• 已掌握 指针基础 和 指针运算
• 理解函数指针和回调函数的概念
• 熟悉 stdint.h 中的固定宽度类型

第一个例子

下面演示 void* 最基础的用法 —— 它可以直接指向任何类型的变量：

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

int main(void) {
    int32_t  i = 42;
    double   d = 3.14;
    char     c = 'A';

    void *vp1 = &i;  /* void* 可以指向 int */
    void *vp2 = &d;  /* void* 可以指向 double */
    void *vp3 = &c;  /* void* 可以指向 char */

    /* 但要读取值, 必须先转回正确类型 */
    printf("i = %" PRId32 "\n", *(int32_t *)vp1);
    printf("d = %.2f\n",   *(double *)vp2);
    printf("c = '%c'\n",   *(char *)vp3);

    return 0;
}

编译并运行：

gcc -Wall -Wextra -std=c17 -o demo demo.c
./demo

输出：

i = 42
d = 3.14
c = 'A'

这段代码揭示了两件事：

• void* 可以接收任何类型的地址（无需强制转换）
• void* 不能直接解引用 —— 必须先转回具体类型

原理解析

1. void* 的本质

void 在 C 语言中表示"无类型" 或"类型未知"。void* 因此被称为通用指针 (universal pointer)。

void *vp;  /* vp 可以指向任何类型的对象 */

为什么需要 void*？ 因为 C 语言没有泛型函数 —— 同一个函数要处理 int、double、struct 等多种类型时, 只能依赖 void* 抹掉类型信息。

内存中的 void*：和 int*、char* 完全一样 —— 都是存储一个地址。区别在于编译器如何看待它：