About Hello C

一个编程高手是怎样练成的呢？ 惟手熟尔。重在刻意练习。 这意味着不断重复练习，实践，再实践，熟练掌握各种技能。因为，只有反复练习，才能真正掌握。

Hello C 是如何产生的呢？ 这是我在学习 C 语言过程中，不断地编写样例代码，不断点滴积累经验，最终形成的。

C 语言是一个经典且强大的系统编程语言，它简洁、高效、灵活，贴近底层硬件。几乎所有现代操作系统（Linux、Windows、macOS）都由 C 语言编写。然而，C 语言也被公认为是一门较难掌握的语言——它要求程序员手动管理内存，没有垃圾回收，没有内置的安全检查，一不小心就会引入悬空指针、缓冲区溢出等问题。

对于新手来说，Hello C 是一个绝佳的起点。通过这个项目，你不仅能快速入门 C 编程，还能通过编写、调试、运行示例代码，迅速掌握 C 语言的核心知识点，熟悉基础语法和核心概念。更棒的是，它还涵盖了高级进阶知识，让你从入门走向精通。

本书假设你使用 C17 标准或更高版本，编译器为 GCC 12+（Linux/Solaris）或 Clang 15+（macOS/FreeBSD）。请查看 Getting Started 的"安装"部分了解如何配置 C 语言开发环境。

Introduction

C 语言是一种通用的、过程式的编程语言，专注于性能、控制和灵活性。由 Dennis Ritchie 于 1972 年在贝尔实验室开发，最初是为了编写 UNIX 操作系统而设计。如今，C 语言仍然是世界上最广泛使用的编程语言之一，是操作系统、嵌入式系统、编译器和高性能应用的基础。

C 语言的设计哲学是"信任程序员"——它提供了对内存和硬件的直接访问，赋予程序员极大的控制力。与高级语言不同，C 没有内置的垃圾回收机制或边界检查，这意味着一切性能优化的可能性都向你开放，但同时也要求你对每一行代码负责。

C 语言支持多种编程范式。它本质上是过程式的，但通过结构体、联合体和函数指针等机制，也能实现面向对象和泛型编程的模式。C 语言的简洁语法和强大的预处理器让它既能编写简单的脚本，也能构建复杂的系统软件。

为什么选择 C 语言？

• 性能：C 语言贴近硬件，编译器生成的机器码非常高效。几乎任何需要极致性能的场景——操作系统、数据库、游戏引擎、编译器——都能看到 C 语言的身影。
• 控制力：你完全掌控内存分配、数据结构布局、系统调用。没有隐藏的运行时代价，没有不可预测的垃圾回收停顿。
• 可移植性：C 语言是跨平台的通用语言。一套 C 代码经过适当处理，可以在 macOS、Linux、Windows、FreeBSD、Solaris 等多种平台上编译运行。
• 基础性：学习 C 语言能让你真正理解计算机如何工作——内存、指针、栈、堆、系统调用。这些知识将伴随你的整个编程生涯。
• 简洁性：C 语言的关键字只有 32 个，语法简洁紧凑。代码风格统一，可读性强。配合 -Wall -Wextra -Werror 编译器警告，能帮你在编码阶段就发现问题。

C 语言的学习曲线

C 语言以"难学"著称，主要是因为它把很多责任交给了程序员：

• 内存管理是手动的（malloc / free）
• 指针需要精确理解
• 没有内置的字符串类型
• 没有异常处理机制

但正因为如此，掌握了 C 语言的程序员，再学习其他任何语言都会觉得轻松自如。C 语言是程序员的"基本功"训练。

Getting Started

安装 C 编译器

首先，你需要安装一个 C 编译器。hello-c 项目支持 GCC（Linux/Solaris）和 Clang（macOS/FreeBSD）。

macOS

macOS 通常预装了 Clang。如果没有，可以通过 Xcode Command Line Tools 安装：

$ xcode-select --install

也可以通过 Homebrew 安装 GCC：

$ brew install gcc

验证安装：

$ clang --version    # 或 gcc --version

Linux

大多数 Linux 发行版都自带 GCC。如果没有，可以使用包管理器安装：

Ubuntu/Debian:

$ sudo apt-get install build-essential

Fedora/Red Hat:

$ sudo dnf groupinstall "Development Tools"

Arch Linux:

$ sudo pacman -S gcc

验证安装：

$ gcc --version

Windows

推荐使用 MSYS2 + MinGW-w64 或 WSL（Windows Subsystem for Linux）：

MSYS2:

# 安装 MSYS2 后，在 MSYS2 终端中运行：
$ pacman -S mingw-w64-x86_64-gcc

WSL:

# 在 WSL 中安装 Linux 发行版（如 Ubuntu）后：
$ sudo apt-get install build-essential

安装构建工具

hello-c 使用 GNU Make 作为构建系统。大多数系统已预装 make。

验证安装：

$ make --version

如果没有安装：

• macOS: $ brew install make
• Ubuntu: $ sudo apt-get install make
• Fedora: 已包含在 build-essential 中

克隆项目

$ git clone https://github.com/your-org/hello-c.git
$ cd hello-c

你应该会看到以下目录结构：

hello-c/
├── Makefile              # 构建脚本
├── include/              # 公共头文件
├── src/                  # 源代码
│   ├── main.c            # 程序入口
│   ├── basic/            # 基础教程代码
│   ├── advance/          # 进阶教程代码
│   └── ...
├── docs/                 # mdBook 文档
│   └── src/              # 文档源文件
└── build/                # 编译输出（git 忽略）

编译与运行

编译项目

$ make build

这将使用 gcc -Wall -Wextra -Werror -std=c17（或 clang 等价选项）编译所有 src/ 下的 .c 文件，输出到 build/bin/hello。

运行教程

$ make run

这将编译并运行 hello 程序，依次执行基础入门教程的所有章节。

清理构建

$ make clean

删除 build/ 目录中的所有编译产物。

查看帮助

$ make help

显示所有可用的 Make 目标和配置信息。

阅读文档

教程文档由 mdBook 生成。你可以本地预览：

$ cd docs
$ mdbook serve --open

这将在本地启动一个文档服务器，并自动在浏览器中打开。当你编辑文档时，页面会自动刷新。

安装 mdBook：

$ cargo install mdbook
# 或使用预编译版本
$ brew install mdbook  # macOS

编辑器推荐

• VS Code: 免费的 C/C++ 插件提供语法高亮、智能补全和调试
• Neovim/Vim: 轻量级，配合 LSP 插件体验优秀
• CLion: JetBrains 出品，功能完善（付费）
• Sublime Text: 简洁快速，适合快速编辑

接下来

• 📖 阅读 Introduction — 了解 C 语言的特点
• 📖 阅读 About Hello C — 了解这个项目的背景
• 📖 阅读 基础入门 — 开始你的 C 语言学习之旅

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: 基础概念 🟢       │
                         │   (12 章, ~4.5 小时)     │
                         └───────────┬─────────────┘
                                     │
           ┌─────────────────────────┼───────────────────────┐
           │                         │                       │
     变量→类型→运算符           函数→数组→循环          预处理→命令行
           │                         │                       │
           └────────────┬────────────┘                       │
                        │                                    │
                  控制流 + 枚举 + typedef ◄──────────────────┘
                        │
                        ↓
                         ┌─────────────────────────┐
                         │   US2: 中级概念 🟡       │
                         │   (5 章 + 14 子章, ~6h)  │
                         └───────────┬─────────────┘
                                     │
                 ┌───────────────────┼───────────────┐
                 │                   │               │
           指针 (5 子章)         字符串 (4 子章)   结构体 (5 子章)
           (最难点)                              联合体 + 作用域
                 │                   │               │
                 └───────────────────┼───────────────┘
                                     │
                                     ↓
                         ┌─────────────────────────┐
                         │   US3: 高级概念 🔴       │
                         │   (12 章, ~6.5 小时)     │
                         └───────────┬─────────────┘
                                     │
            ┌────────────────────────┼────────────────────┐
            │                        │                    │
         内存管理                函数指针 + void*     文件 I/O + 头文件
         (最重要)              + 回调 (C 的多态)
             │                        │                    │
             └────────────┬───────────┘                    │
                          │                                │
           位运算 + 标准库 ◄──────────────────┘
           (系统编程基础)
                         │
                         ↓
                     🎓 毕业 → 高级进阶

依赖关系说明：

• 🔵 US1 → US2：理解指针前必须先掌握变量、数组和函数
• 🔵 US2 → US3：理解内存管理前必须先掌握指针运算
• 🔵 指针 → 函数指针：函数指针是指针概念的延伸
• 🔵 结构体 + 函数指针 → 回调：回调需要这两者的组合
• 🔵 位运算前置：位运算在 operators 中初步接触，US3 中深入

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

✅ 学习清单

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

US1 基础概念:

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

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 实现经典算法（Coming Soon）：

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

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

📊 统计总览

📈 学习路径

变量 → 数据类型 → 运算符 → 控制流 → 循环 → 函数 → 数组 → 预处理器
→ 条件编译 → 枚举 → typedef
→ 指针 (基础→运算→void*→数组→函数→const) → 字符串 (基础→操作→安全→处理)
→ 结构体 (基础→嵌套→函数→内存布局) → 联合体 → 作用域
→ 内存管理 → 头文件 → 日志 → 调试 → 文件 I/O
→ 函数指针 → 回调 → 可变参数 → 位运算 → 标准库 → 命令行参数
→ 递归 → 术语表 → 复习 → 🎓 毕业

📚 延伸阅读

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

• 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 更可靠。

变量在栈帧中的内存布局:

地址偏移:  0    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15
         ┌────────────────────┐ ┌──────────────────────────────────┐ ┌────────────────┐
变量:    │        a           │ │                b                 │ │      sum       │
类型:    │    int (4 字节)    │ │          double (8 字节)          │ │   int (4 字节)  │
值:      │        10          │ │                3.5               │ │       15       │
         └────────────────────┘ └──────────────────────────────────┘ └────────────────┘

C 变量存储 vs Python 动态类型:

  C (栈上, 固定大小):                Python (堆上, 动态类型):
  ┌────────────────────────────┐    ┌──────────────────────────────┐
  │ int a = 10                │    │ a = 10                      │
  │ 字节: [0x0A 00 00 00]     │    │ a 实际上是指针 → PyObject    │
  │ 占用: sizeof(int) = 4 字节 │    │  { type=int, value=10        │
  │ 编译时确定, 连续排列       │    │    refcount=1 }              │
  │                           │    │ 占用: ~28 字节 (堆上分配)    │
  └────────────────────────────┘    └──────────────────────────────┘

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__）或真正的编译时常量。

变量内存布局：

┌──────────────────────────────────────────────────────┐
│              C 变量内存布局 (Memory Layout)            │
│                                                      │
│  内存地址 ↑                                           │
│  ┌─────────────────────────────────────┐              │
│  │  栈 (Stack)                         │              │
│  │  局部变量: int a = 10;              │ ← 函数返回   │
│  │  函数参数                           │   时销毁     │
│  ├─────────────────────────────────────┤              │
│  │  堆 (Heap)                          │              │
│  │  int *p = malloc(...);              │ ← 手动分配   │
│  │                                     │   和释放     │
│  ├─────────────────────────────────────┤              │
│  │  .data (已初始化数据段)              │              │
│  │  全局变量: int global = 100;        │ ← 程序启动   │
│  │                                     │   到结束     │
│  ├─────────────────────────────────────┤              │
│  │  .rodata (只读数据段)                │              │
│  │  const int MAX = 100;               │ ← 只读不可   │
│  │  字符串字面量: "hello"              │   修改       │
│  └─────────────────────────────────────┘              │
└──────────────────────────────────────────────────────┘

作用域基础

变量的作用域（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 */

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

🎯 预测运行结果

先别急着运行——读下面的代码，预测它会输出什么？

int32_t a = 5;
int32_t b = a++;
int32_t c = ++a;
printf("a=%d, b=%d, c=%d\n", (int)a, (int)b, (int)c);

a=7, b=5, c=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> 提供了一组精确宽度类型，保证在所有平台上大小一致：

整数类型内存占用对比：

┌──────────────────────────────────────────────────────┐
│           整数类型内存占用对比 (Memory Footprint)       │
│                                                      │
│  int8_t   ┌────┐  范围: -128 ~ 127                   │
│  (1 字节) └────┘                                     │
│                                                      │
│  int16_t  ┌────────────┐  范围: -32,768 ~ 32,767     │
│  (2 字节) └────────────┘                             │
│                                                      │
│  int32_t  ┌────────────────────────┐  范围: ±21 亿   │
│  (4 字节) └────────────────────────┘                 │
│                                                      │
│  int64_t  ┌─────────────────────────────────────────┐│
│  (8 字节) └─────────────────────────────────────────┘│
│                                    范围: ±9.2×10¹⁸   │
└──────────────────────────────────────────────────────┘

#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 类型。

C 整数类型大小金字塔 (从最小到最大):

                         ┌──────────────────────┐
                         │      int8_t          │
                         │      1 字节          │
                         │    -128 ~ 127        │
                        ┌┴──────────────────────┴┐
                        │      int16_t           │
                        │      2 字节            │
                        │   -32,768 ~ 32,767    │
                       ┌┴────────────────────────┴┐
                       │      int32_t              │
                       │      4 字节               │
                       │    ±2.1 × 10⁹            │
                      ┌┴──────────────────────────┴┐
                      │      int64_t               │
                      │      8 字节                │
                      │    ±9.2 × 10¹⁸            │
                      └────────────────────────────┘

         ⚠️ 溢出边界: 类型大小决定安全范围
         ┌──────────────────────────────────────────┐
         │ int8_t  n = 200;     // ❌ 编译器警告!    │
         │ // n 实际存储为 -56 (溢出回绕)            │
         │ // 二进制: 200 = 11001000                │
         │ // int8_t 只能存 -128 ~ 127              │
         └──────────────────────────────────────────┘

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");
}

🎯 预测运行结果

先别急着运行——读下面的代码，预测它会输出什么？

int32_t x = 7;
int32_t y = 2;
printf("%d / %d = %d\n", (int)x, (int)y, (int)(x / y));
printf("%d / %d = %.1f\n", (int)x, (int)y, (double)x / (double)y);
printf("7 %% 2 = %d\n", (int)(x % y));

7 / 2 = 3
7 / 2 = 3.5
7 % 2 = 1

小结

本章介绍了 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 查看完整演示输出。

运算符与表达式（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 是一个编译期运算符，不是函数！

🎯 预测运行结果

先别急着运行——读下面的代码，预测它会输出什么？

int32_t i = 1;
printf("%d\n", (int)(i += 3));
i = 1;
i++;
printf("%d\n", (int)(++i));
i = 1;
++i;
printf("%d\n", (int)(i++));
printf("%d\n", (int)i);

4
3
2
3

小结

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

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

术语表

延伸阅读

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

继续学习

掌握了运算符，你已经能写出丰富的表达式了！下一章我们将学习控制流，了解如何让程序根据条件做出不同的选择。

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

控制流：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 {
    // 所有条件都不为真 → 执行这里
}

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

条件分支的执行流程:

                  ┌──────────────┐
                  │  程序进入     │
                  └──────┬───────┘
                         │
                   ┌─────▼──────┐
                   │ if (条件1)  │
                   └──┬──────┬──┘
                      │真    │假
                 ┌────▼──┐ ┌─▼─────────┐
                 │ 分支1  │ │ else if   │
                 │        │ │ (条件2)    │
                 └────┬──┘ └──┬───────┬─┘
                      │     真│       │假
                      │ ┌────▼──┐  ┌──▼─────┐
                      │ │ 分支2 │  │ 分支3  │
                      │ │       │  │(else)  │
                      │ └────┬──┘  └──┬─────┘
                      │      │       │
                      └──────┴───────┘
                             │
                    ┌────────▼────────┐
                    │  后续代码继续执行 │
                    └─────────────────┘

switch  vs  if-else 的选择:

  多分支定值比较 → switch   (如: day = 1~7)
  范围/复杂条件 → if-else  (如: score >= 60)

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

⚠️ 知识陷阱预警：switch fall-through

C 语言 switch 最著名的陷阱是 fall-through：如果 case 后面没有 break，程序会直接"掉落"执行下一个 case 的代码。

int32_t level = 2;
switch (level) {
    case 1:
        printf("初级\n");
        break;
    case 2:
        printf("中级\n");
        // ← 忘了 break！
    case 3:
        printf("高级\n");
        break;
    default:
        printf("未知\n");
}
/* 输出：
   中级
   高级     ← 意外！这不是我们想要的
*/

但 fall-through 有时是有意为之的设计，不是 bug：

/* ✅ 故意 fall-through：多个 case 共用同一行为 */
switch (ch) {
    case 'a': case 'e': case 'i':
    case 'o': case 'u':
        printf("元音\n");
        break;
    default:
        printf("辅音\n");
}

C23 引入了 [[fallthrough]] 属性来标记有意的 fall-through。在现代代码中，每个 case 应该显式以 break、return、continue 或 [[fallthrough]] 结束。

编译器警告：-Wimplicit-fallthrough（GCC/Clang）会在忘记 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;
    // 真正逻辑在这里，少了一层缩进
}

🎯 预测运行结果

先别急着运行——读下面的代码，预测它会输出什么？

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

int main(void) {
    int32_t num = 2;
    switch (num) {
        case 1:
            printf("一 ");
        case 2:
            printf("二 ");
        case 3:
            printf("三 ");
            break;
        default:
            printf("其他 ");
    }
    printf("结束\n");
    return 0;
}

二 三 结束

小结

通过这一章我发现：

• 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);

三种循环的执行流程对比：

─── for 循环 (已知次数) ──────────────────────────────────
    ┌──────────┐      ┌──────────┐      ┌──────────┐
    │ ① 初始化 │ ──→  │ ② 条件判 │ 真→  │ ③ 循环体 │ ──→  │ ④ 递增 │ ──→ ②
    │ int i=1  │      │ i <= 5   │      │ printf() │      │ i++    │
    └──────────┘      └────┬─────┘      └──────────┘      └────────┘
                           │ 假
                           ▼
                         退出

─── while 循环 (条件驱动) ────────────────────────────────
    ┌──────────┐      ┌──────────┐
    │ ① 条件判 │ 真→  │ ② 循环体 │ ──→ ①
    │ i <= 100 │      │ sum+=i   │
    └────┬─────┘      └──────────┘
         │ 假
         ▼
       退出

─── do-while 循环 (至少执行一次) ─────────────────────────
    ┌──────────┐      ┌──────────┐
    │ ① 循环体 │ ──→  │ ② 条件判 │ ──真→ ①
    │ printf() │      │ 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]);

🎯 预测运行结果

先别急着运行——读下面的代码，预测它会输出什么？

for (int32_t i = 0; i < 5; i++) {
    if (i == 3) continue;
    if (i == 4) break;
    printf("%d ", (int)i);
}
printf("\n");

0 1 2

小结

恭喜！你已经掌握了 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 行相似的结构，几乎一定可以用循环简化！

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

函数（Functions）

走进一家专业厨房，你会看到切菜台、灶台、烘焙区各自独立。如果让一个厨师包办所有工序，效率会大打折扣。分工，是效率的来源。

C 语言的函数就是代码里的分工。把一段逻辑打包成一个函数，等于在程序里开了一个专门的工作台。main() 不必包办一切——它只需要调度：调用 calculate() 算结果，调用 print_result() 打输出。每个函数只做一件事，但把这件事做好。

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

第一个例子

#include <stdio.h>

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

int main(void) {
    int result = add(3, 5);
    printf("3 + 5 = %d\n", result);
    return 0;
}

一个函数由返回类型、函数名、参数列表和函数体组成。main 调用 add 时，程序会跳转到 add 的代码执行，然后把结果带回来。

你会学到什么

本章是函数的总览。深入的内容请到对应的子章节学习：

• 函数基础 —— 声明与定义、参数传递、返回值、void 函数、前向声明
• 函数作用域 —— 局部/全局变量、static 关键字、extern、链接属性
• 递归函数 —— 基线条件、阶乘、斐波那契、调用栈可视化
• 可变参数函数 —— va_list、printf 原理、哨兵模式

继续学习

函数是 C 语言模块化的基础。学完函数基础后，下一节将从声明与定义开始，深入函数的各个细节。

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

上一章：循环 | 下一章：函数基础

函数基础 (Function Basics)

"我发现，函数就像厨房里的专用工具——每个工具只做一件事，但你把它们组合起来就能做出一顿大餐。" —— 我的理解

开篇故事

走进一个专业的厨房。你看到切菜板、打蛋器、榨汁机、烤箱——每种工具都有一个明确的职责。切菜板不负责加热，烤箱不负责搅拌。但当你组合这些工具时，就能做出一道完整的菜。

函数（Function）就是编程世界里的「专用工具」。一个函数只做一件事：计算面积、打印日志、验证输入。单独看，每个函数都很简单；但组合起来，就能构建复杂的程序。

C 语言没有「类」或「对象」的概念，函数就是它最重要的代码组织单元。整个 C 标准库——printf、malloc、strlen——全是函数。

"把大任务拆成小函数，就像把大工程拆成工序——每一步都可控，每一步都可复用。"

本章适合谁

• 已经理解变量、数据类型、运算符的 C 初学者
• 第一次接触函数概念，想搞清楚「声明」和「定义」区别的人
• 被编译器「implicit declaration」错误搞晕过的人
• 想理解参数传递（值传递）和返回机制的人

你会学到什么

• 函数的声明（Declaration）与定义（Definition）——为什么必须先声明后使用
• 参数（Parameters）——单参数、多参数、值传递（Pass by Value）
• 返回类型（Return Type）——int、float、char、void
• return 关键字的作用——返回值并退出函数
• 调用约定——如何正确地调用一个函数
• 常见错误与修复方法

前置要求

• 了解 C 基本数据类型（int、float、char）
• 会使用 printf 输出
• 掌握变量声明和赋值
• 了解运算符（+、-、*、/、%）

如果还没学过「循环」，建议先看「循环」章节——函数和循环常常一起使用。

第一个例子

#include <stdio.h>

/* 函数声明：告诉编译器 add 函数存在 */
int add(int a, int b);

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

/* 函数定义：实现 add 的具体逻辑 */
int add(int a, int b) {
    return a + b;
}

运行结果：

3 + 5 = 8

拆解一下这个例子中发生了什么：

1. 声明 int add(int a, int b); — 告诉编译器「有一个叫 add 的函数，它接收两个 int，返回一个 int」
2. 定义 int add(int a, int b) { return a + b; } — 告诉编译器「add 函数实际上做了什么」
3. 调用 add(x, y) — 在 main 函数中调用 add，传入 x 和 y 的值
4. 返回 return a + b; — 计算结果 8 返回给调用者

原理解析

1. 声明 vs 定义

声明（Declaration） 是「预告」——它告诉编译器函数的签名（返回值类型 + 函数名 + 参数列表），但不包含具体的实现。

定义（Definition） 是「正片」——它包含函数实际执行的代码。

/* 声明：只有签名，没有实现 */
int multiply(int x, int y);

/* 定义：签名 + 实现体 */
int multiply(int x, int y) {
    return x * y;
}

我的理解：声明像菜单上的菜名（告诉你有什么），定义像厨师的配方（告诉你怎么做）。

在 C 语言中，函数必须先声明后使用。如果定义出现在调用之前，可以省略单独的声明（定义本身就充当了声明）。但如果定义在调用之后，就一定要先声明：

/* ❌ 错误：在定义之前调用，编译器不知道 greeting 是什么 */
int main(void) {
    greeting("World");  /* 编译错误 */
    return 0;
}

void greeting(const char *name) {
    printf("Hello, %s!\n", name);
}

/* ✅ 正确：先声明，再调用，最后定义 */
void greeting(const char *name);  /* 声明在前 */

int main(void) {
    greeting("World");  /* ✅ 编译器知道了签名 */
    return 0;
}

void greeting(const char *name) {
    printf("Hello, %s!\n", name);  /* 定义在后 */
}

2. 参数（Parameters）：值传递（Pass by Value）

C 语言中，函数参数是值传递的。调用函数时，实参的值会被复制一份传给形参，原变量不会改变。

void double_value(int x) {
    x = x * 2;
    printf("  函数内部: x = %d\n", x);  /* 修改的是副本 */
}

int main(void) {
    int num = 21;
    printf("  调用前: num = %d\n", num);   /* 21 */
    double_value(num);
    printf("  调用后: num = %d\n", num);   /* 21 — 没变！ */
    return 0;
}

  调用前: num = 21
  函数内部: x = 42      ← 函数内改了副本
  调用后: num = 21      ← 原变量不受影响

ASCII 内存示意图——值传递时发生了什么：

调用 double_value(num) 时：

栈空间:
┌─────────────────────┐
│ main() 的栈帧       │
│   num = 21 ← 原始值 │
│                     │
├─────────────────────┤
│ double_value() 栈帧 │
│   x = 21 ← 复制品！  │  ← 修改 x 不影响 num
│                     │
└─────────────────────┘

我的理解：想象你给朋友复印了一份文件。朋友在复印件上写字，原件上不会有任何变化。值传递就是这样——函数拿到的是「复印件」。

3. 返回类型（Return Type）

函数的返回类型决定了它「吐出」什么类型的数据：

/* 返回 int */
int square(int n) {
    return n * n;
}

/* 返回 float */
float half(float n) {
    return n / 2.0f;
}

/* 返回 char */
char grade(int score) {
    if (score >= 90) return 'A';
    if (score >= 80) return 'B';
    if (score >= 60) return 'C';
    return 'F';
}

/* 返回 void（无返回值）——只做一件事，不返回数据 */
void print_separator(void) {
    printf("-------\n");
}

void 表示「这个函数什么都不返回」。它只执行操作（如打印、修改全局变量等）。

我的理解：void 函数就像工厂里的机器——它干活（打孔、喷漆），但不产出可以带走的东西。

4. return 关键字

return 做两件事：

1. 返回一个值（如果是 void 函数则没有值）
2. 立即退出当前函数，回到调用者

int absolute(int n) {
    if (n >= 0) {
        return n;    /* 退出函数，返回 n */
    }
    return -n;       /* 退出函数，返回 -n */
}

void 函数也可以用 return; 提前退出：

void print_if_positive(int n) {
    if (n <= 0) {
        return;  /* 提前退出，什么都不打印 */
    }
    printf("%d\n", n);
}

我常犯的错：忘记非 void 函数的所有路径都有 return。如果控制流走到了函数末尾却没有 return，编译器会报错（尤其是用了 -Wall -Werror 时）。

5. 单参数 vs 多参数

/* 单参数 */
double square_root(double x) {
    /* ... */
}

/* 多参数（用逗号分隔） */
int max_of_three(int a, int b, int c) {
    int max = a;
    if (b > max) max = b;
    if (c > max) max = c;
    return max;
}

/* 无参数 */
int get_constant(void) {
    return 42;
}

注意：C 语言中 void 在参数列表中明确表示「没有参数」。写成 int func() （空括号）在 C 中表示「参数未知」（C 风格），而 int func(void) 才是「无参数」（现代推荐写法）。

Python / JavaScript 对比

常见错误

❌ 错误 1：调用未声明的函数

int main(void) {
    int result = add(3, 5);  /* ❌ 编译器不知道 add 是什么 */
    return 0;
}

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

编译器报错（C99 之后）：

error: implicit declaration of function 'add' [-Werror=implicit-function-declaration]

我最初的困惑：明明 add 函数在后面定义了，为什么不能用？

✅ 修正：先声明后使用。

int add(int a, int b);  /* ✅ 声明在前 */

int main(void) {
    int result = add(3, 5);  /* ✅ 编译器知道了签名 */
    return 0;
}

int add(int a, int b) {     /* 定义在后 */
    return a + b;
}

原理：C 编译器是「从上到下」编译的。读到 add(3, 5) 时，如果还没见过声明，就不知道 add 接受什么参数、返回什么类型。

❌ 错误 2：返回类型不匹配

int get_name(void) {
    return "hello";  /* ❌ "hello" 是字符串（char*），不是 int */
}

✅ 修正：让返回类型与实际返回值匹配。

const char *get_name(void) {  /* ✅ 返回字符串指针 */
    return "hello";
}

❌ 错误 3：忘记使用返回值（编译器警告）

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

int main(void) {
    add(3, 5);  /* ⚠️ 调用了但没有使用返回值 — 相当于白算 */
    return 0;
}

有些编译器会给出 unused value 警告。

✅ 修正：接收返回值或明确丢弃它。

int main(void) {
    int result = add(3, 5);  /* ✅ 使用返回值 */
    printf("%d\n", result);
    return 0;
}

❌ 错误 4：参数类型不匹配

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

int main(void) {
    double x = 3.5, y = 5.7;
    int result = add(x, y);  /* ⚠️ double 隐式转 int，丢失小数部分 */
    return 0;
}

结果：add(3.5, 5.7) 实际计算的是 3 + 5 = 8（小数被截断）。

✅ 修正：参数类型匹配。

double add_double(double a, double b) {
    return a + b;
}

int main(void) {
    double x = 3.5, y = 5.7;
    double result = add_double(x, y);  /* ✅ 3.5 + 5.7 = 9.2 */
    return 0;
}

动手练习

🟢 练习 1：编写 multiply 函数

写一个函数 int multiply(int a, int b)，返回两个整数的乘积。在 main 中调用它。

/* 提示：把 add 函数中的 return a + b 改成 return a * b */

#include <stdio.h>

int multiply(int a, int b) {
    return a * b;
}

int main(void) {
    printf("6 × 7 = %d\n", multiply(6, 7));  /* 42 */
    return 0;
}

🟡 练习 2：编写 is_even 函数（返回布尔值）

写一个函数 int is_even(int n)，如果 n 是偶数返回 1（真），否则返回 0（假）。在 main 中用 printf 判断数字。

/* 提示：偶数 % 2 == 0；C 中没有 bool 类型，用 int 代替 */

#include <stdio.h>

int is_even(int n) {
    return (n % 2) == 0;  /* 结果为 0 或 1 */
}

int main(void) {
    int nums[] = {2, 3, 4, 5, 6};
    for (int i = 0; i < 5; i++) {
        printf("%d 是%s偶数\n",
               nums[i], is_even(nums[i]) ? "" : "不");
    }
    return 0;
}

🔴 练习 3：同时返回和与差（使用指针）

写一个函数 void sum_and_diff(int a, int b, int *sum, int *diff)，通过指针参数同时返回 a+b 和 a-b 的结果。

/* 高级提示：
   1. 参数 sum 和 diff 是指针类型
   2. 在函数内用 *sum = ... 和 *diff = ... 写入结果
   3. 调用时用 &result_sum 和 &result_diff 传入变量地址
*/

#include <stdio.h>

void sum_and_diff(int a, int b, int *sum, int *diff) {
    *sum = a + b;   /* 通过指针写入结果 */
    *diff = a - b;  /* 通过指针写入结果 */
}

int main(void) {
    int x = 10, y = 3;
    int result_sum, result_diff;

    sum_and_diff(x, y, &result_sum, &result_diff);

    printf("%d + %d = %d\n", x, y, result_sum);   /* 13 */
    printf("%d - %d = %d\n", x, y, result_diff);   /* 7 */
    return 0;
}

故障排查（FAQ）

Q: 为什么编译器说 "implicit declaration of function"？

A: 这意味着你在声明或定义之前调用了这个函数。C 编译器从上到下扫描，读到函数调用时必须知道它的签名。

修复方法：在函数调用之前添加声明（如 int add(int a, int b);），或者把函数定义移到调用处之前。

Q: 函数可以没有 return 语句吗？

A: 只有 void 函数可以没有 return。非 void 函数如果所有执行路径都有 return，可以省略最后的 return（但编译器可能会警告）。建议所有路径都写上 return。

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

A: 不能直接返回数组。 C 语言规定 return 只能返回一个值（标量）。但可以：

1. 返回指向数组的指针（需要确保指针指向的内存仍然有效）
2. 把数组封装在 struct 中返回
3. 让调用者传入一个数组指针，由函数填充

/* 方式 3: 调用者分配——推荐 */
void fill_array(int *arr, int n) {
    for (int i = 0; i < n; i++) {
        arr[i] = i * i;
    }
}

int main(void) {
    int data[5];
    fill_array(data, 5);
    return 0;
}

Q: int func() 和 int func(void) 一样吗？

A: 不一样，但在现代 C 中应该用 void：

• int func() — 旧式声明，表示「参数未知」，编译器不检查参数
• int func(void) — 明确表示「没有参数」，编译器会检查

总是用 func(void)，这是 C99 之后的推荐写法。

Q: 一个函数可以有多个 return 语句吗？

A: 可以！每个 return 都会立即退出函数。常用于提前返回：

int divide(int a, int b) {
    if (b == 0) {
        return 0;  /* 除数为 0，提前返回 */
    }
    return a / b;   /* 正常情况 */
}

知识扩展（选学）

内联函数（Inline Functions）— C99 引入

inline 关键字提示编译器将函数体直接展开到调用处，消除函数调用开销。适用于短小且频繁调用的函数：

/* 内联函数：编译器可能直接展开代码 */
static inline int max(int a, int b) {
    return (a > b) ? a : b;
}

我的理解：内联就像把小工具直接搬到工作台上，而不是每次都要去工具箱里拿。省去了「走过去拿—用完放回」的开销。

注意：inline 只是提示，编译器不一定要照做。而且 C 的内联函数必须搭配 static 使用（在每个包含它的 .c 文件中都有定义）。

文件内的 static 函数

在 C 中，如果你希望一个函数只在当前源文件内可见，其他 .c 文件不能调用，可以用 static：

/* utils.c */
static void helper_internal(void) {
    /* 只有 utils.c 能调用它 */
}

/* 这是对外接口 */
void public_api(void) {
    helper_internal();  /* 同一文件，可以调用 */
}

在其他文件中：

/* main.c */
extern void helper_internal(void);  /* ❌ 链接错误：helper_internal 不可见 */

模式：公开函数放头文件声明，内部 static 函数不声明。这就是模块化的基础——隐藏实现细节。

小结

恭喜！你已经了解了 C 语言函数的核心概念。让我帮你回顾一下——

• 声明告诉编译器函数存在（签名），定义是函数的具体实现
• C 语言函数必须先声明后调用（除非定义在调用之前）
• 参数是值传递（Pass by Value）——函数收到的是实参的副本，修改不影响原变量
• 返回类型可以是 int、float、char 等任何类型，也可以是 void（无返回值）
• return 关键字返回值并退出函数
• 常见错误：调用未声明函数 → 加声明；返回类型不匹配 → 改类型；忘记使用返回值 → 接收它

我的理解：函数的本质是「封装」——把一段有特定功能的代码打包成一个工具，给它取个名字。下次需要时，只需调用名字就行。好的函数应该「单一职责」——只做一件事，但做得好。

术语表

延伸阅读

• cppreference: Functions (C)
• Beej's Guide to C: Functions
• K&R《C 程序设计语言》第 1.7 节：函数
• 《C Primer Plus》第 5 章：C 语句

继续学习

函数是 C 语言中最重要的代码组织工具。现在你已经理解了函数的基本概念，下一章我们将深入探讨函数的作用域与链接——static、extern 关键字如何控制函数在文件间的可见性。

💡 提示：试着把你之前写的重复代码（比如循环中的重复计算）提取成函数。如果一个代码片段出现了两次以上，它可能就应该是一个函数！

← 上一章：循环 | 下一章：函数作用域 →

函数作用域（Function Scope & Visibility）

"函数作用域就像办公室的门——有的门谁都看得见，有的门只有内部员工能进。" —— 我发现

开篇故事

想象一栋办公大楼。一楼大门的标识所有人都能看到（全局函数），但某些办公室只有佩戴特定门禁卡的员工才能进入（static 函数）。有些功能虽然大楼里存在，但前台没有登记（缺少前向声明），你即使知道它的名字也找不到路。

C 语言中的函数也有这样的"可见性"规则：有的函数整个程序都能调用，有的函数只能在自己的 .c 文件内部使用，还有的函数需要先"预告"才能调用。理解这些规则，你就能写出模块化、可维护的代码——并且避免各种"找不到函数"的链接错误。

函数作用域不是关于"函数能访问哪些变量"，而是关于**"哪些代码能访问这个函数"**。

"函数在哪里声明，就在哪里可见；加了 static，就只能在自己的文件里称王。"

本章适合谁

• 已经写了几个函数，但对 static 函数的作用一知半解的人
• 被过"undefined reference" 链接错误，想知道为什么的人
• 想理解头文件中声明和 .c 文件中定义之间关系的人
• 好奇"前向声明"到底解决了什么问题的人

你会学到什么

• 局部变量 vs 全局变量在函数中的行为差异
• 变量遮蔽（Shadowing）及其风险
• static 函数：限制函数只在当前文件可见（内部链接）
• extern 函数：跨文件调用函数（外部链接）
• 前向声明（Forward Declaration）：为什么需要它、怎么用
• 函数作用域与变量作用域的本质区别

前置要求

• 已完成「函数基础](./functions.md) 章节，理解函数声明、定义、参数传递
• 已完成「变量与表达式](./variables.md) 章节，理解变量声明与作用域

如果还没学函数基础，建议先看「函数」章节。

第一个例子：局部变量 vs 全局变量

#include <stdio.h>

int global_value = 100;  /* 全局变量：所有函数可见 */

void print_values(void) {
    int local_value = 50;  /* 局部变量：仅本函数可见 */
    printf("global = %d, local = %d\n", global_value, local_value);
}

/* 下列函数无法访问 local_value！ */
void try_access(void) {
    /* printf("%d", local_value);  ❌ 编译错误：局部变量不可见 */
    printf("global = %d\n", global_value);  /* ✅ 全局变量可见 */
}

int main(void) {
    print_values();
    try_access();
    return 0;
}

运行结果：

global = 100, local = 50
global = 100

关键点：

• global_value 在 main() 外面声明，整个文件中所有函数都能看到它
• local_value 在 print_values() 里面声明，只有 print_values() 能看到它
• try_access() 试图访问 local_value 会触发编译错误

原理解析

1. 变量作用域 vs 函数作用域

在学习函数之前，我们已经知道了变量有作用域（块作用域、文件作用域）。函数的"作用域"规则类似，但多了一个维度：链接类型（Linkage）。

ASCII 作用域金字塔：

┌──────────────────────────────────────────────────────┐
│              变量作用域金字塔 (Scope Pyramid)          │
│                                                      │
│             ┌────────────────────┐                    │
│             │   程序作用域        │ ← extern 跨文件   │
│             │  (Program Scope)   │                    │
│             └────────┬───────────┘                    │
│                      │                               │
│             ┌────────┴───────────┐                    │
│             │   文件作用域        │ ← 全局/static    │
│             │  (File Scope)      │                    │
│             └────────┬───────────┘                    │
│                      │                               │
│             ┌────────┴───────────┐                    │
│             │   函数作用域        │ ← 参数/局部变量   │
│             │ (Function Scope)   │                    │
│             └────────┬───────────┘                    │
│                      │                               │
│             ┌────────┴───────────┐                    │
│             │   块作用域          │ ← { } 内变量     │
│             │  (Block Scope)     │                    │
│             └────────────────────┘                    │
│                                                      │
│  作用域越内层，可见范围越小，生命周期越短                │
└──────────────────────────────────────────────────────┘

2. 函数的链接类型（Linkage）

C 语言中，每个函数都有一个链接类型，决定了其他文件能否看到它：

/* file_a.c */

void public_func(void) {  /* 外部链接：其他文件可以调用 */
    /* ... */
}

static void private_func(void) {  /* 内部链接：只有 file_a.c 能调用 */
    /* ... */
}

/* file_b.c */

extern void public_func(void);  /* ✅ 可以调用 file_a.c 中的 public_func */

int main(void) {
    public_func();    /* ✅ OK */
    /* private_func();  ❌ 链接错误：找不到! */
    return 0;
}

核心概念：

• 没有 static 的函数 = 外部链接（External Linkage） = 其他文件可见
• 有 static 的函数 = 内部链接（Internal Linkage） = 只有当前文件可见

3. static 函数详解

static 用在函数前面，意思是"这个函数只属于当前 .c 文件，别让它出去"：

/* calculator.c */

static int clamp(int value, int min, int max) {
    /* 辅助函数：确保值在 [min, max] 范围内 */
    if (value < min) return min;
    if (value > max) return max;
    return value;
}

/* 公开函数：其他文件可以调用 */
int calculate_score(int raw_score) {
    return clamp(raw_score, 0, 100);  /* ✅ clamp 只在内部用 */
}

为什么用 static？

1. 隐藏实现细节：把辅助函数标记为 static，外部代码无法直接调用它
2. 避免命名冲突：两个不同的 .c 文件可以各有一个叫 helper() 的 static 函数，不会冲突
3. 编译器优化：编译器知道 static 函数只在本文件调用，可以做出更好的优化决策

4. extern 关键字与跨文件调用

extern 告诉编译器"这个函数在别处定义，但我想在这里用它"：

/* module_a.c */

void greeting(const char *name) {
    printf("Hello, %s!\n", name);
}

/* module_b.c */

extern void greeting(const char *name);  /* 声明：greeting 在别处定义 */

void say_hi(void) {
    greeting("World");  /* ✅ 跨文件调用 */
}

5. 前向声明（Forward Declaration）

C 编译器从上往下读取代码。如果函数 A 要调用函数 B，但 B 的定义在 A 的后面，编译器就不认识 B：

/* ❌ 错误示例 —— 没有前向声明 */

void print_result(void) {
    int value = compute_value();  /* ❌ 编译器不认识 compute_value */
    printf("Result: %d\n", value);
}

int compute_value(void) {
    return 42;
}

编译器报错：

error: implicit declaration of function 'compute_value'

✅ 修复：加前向声明

/* ✅ 正确 —— 前向声明 */

int compute_value(void);  /* 前向声明：告诉编译器 compute_value 存在 */

void print_result(void) {
    int value = compute_value();  /* ✅ 编译器已认识 */
    printf("Result: %d\n", value);
}

int compute_value(void) {
    return 42;  /* 定义在后面 */
}

6. 前向声明 vs 头文件

在实际项目中，前向声明通常放在头文件中统一管理：

/* compute.h */
#ifndef COMPUTE_H
#define COMPUTE_H

int compute_value(void);  /* 前向声明放在头文件 */

#endif

/* compute.c */
#include "compute.h"

int compute_value(void) {  /* 定义 */
    return 42;
}

/* main.c */
#include <stdio.h>
#include "compute.h"  /* 通过头文件获得前向声明 */

int main(void) {
    printf("value = %d\n", compute_value());
    return 0;
}

最佳实践：永远用头文件管理函数声明，不要在各处重复手写 extern 声明。

7. 局部变量遮蔽全局变量

当局部变量和全局变量同名时，局部变量会"遮蔽"全局变量：

#include <stdio.h>

int mode = 1;  /* 全局变量 */

void do_work(void) {
    int mode = 2;  /* 局部变量遮蔽了全局变量 */
    printf("inside: mode = %d\n", mode);  /* 输出 2，不是 1 */
}

int main(void) {
    printf("before: mode = %d\n", mode);  /* 输出 1 */
    do_work();
    printf("after:  mode = %d\n", mode);  /* 还是 1 —— 全局变量没被改 */
    return 0;
}

运行结果：

before: mode = 1
inside: mode = 2
after:  mode = 1

常见错误

❌ 错误 1：变量遮蔽导致混淆

#include <stdio.h>

int counter = 10;

void increment(void) {
    int counter = 0;  /* ❌ 遮蔽了全局变量！ */
    counter++;
    printf("%d\n", counter);  /* 每次输出 1，不是递增！ */
}

int main(void) {
    increment();  /* 输出 1 */
    increment();  /* 输出 1（而不是 2） */
    return 0;
}

✅ 修复：使用不同的名字，或者不加 int 声明直接修改全局变量：

void increment(void) {
    /* int counter = 0;  ← 删除这行 */
    counter++;  /* ✅ 直接修改全局变量 */
    printf("%d\n", counter);
}

❌ 错误 2：调用 static 函数导致链接错误

/* utils.c */
static int helper(int x) {
    return x * 2;
}

/* main.c */
int main(void) {
    int result = helper(5);  /* ❌ 链接错误：找不到 helper */
    return 0;
}

编译错误：

undefined reference to `helper'
collect2: error: ld returned 1 exit status

✅ 修复：去掉 static，或通过公开函数间接调用：

/* utils.c */
static int helper(int x) {
    return x * 2;
}

int public_api(int x) {  /* ✅ 公开函数 */
    return helper(x);
}

/* main.c */
extern int public_api(int x);
int main(void) {
    printf("%d\n", public_api(5));  /* ✅ 通过公开接口调用 */
    return 0;
}

❌ 错误 3：缺少前向声明导致隐式声明警告

void print_hello(void) {
    greet();  /* ❌ greet 还没声明，编译器假设它返回 int */
}

void greet(void) {
    printf("Hello!\n");
}

现代编译器会用 -Werror=implicit-function-declaration 将其视为错误。

✅ 修复：添加前向声明：

void greet(void);  /* 前向声明 */

void print_hello(void) {
    greet();  /* ✅ OK */
}

动手练习

🟢 练习 1：创建一个 static 辅助函数

/* 写一个 .c 文件：
   - 定义一个 static 函数 is_positive(int n)，判断 n 是否大于 0
   - 定义一个公开函数 print_sign(int n)，调用 is_positive() 打印 "+", "-" 或 "0"
   在另一个 .c 文件中尝试直接调用 is_positive()，观察链接错误 */

/* sign.c */
#include <stdio.h>

static int is_positive(int n) {
    return n > 0;
}

static int is_negative(int n) {
    return n < 0;
}

void print_sign(int n) {
    if (is_positive(n)) {
        printf("+");
    } else if (is_negative(n)) {
        printf("-");
    } else {
        printf("0");
    }
    printf("\n");
}

/* main.c */
#include <stdio.h>

extern void print_sign(int n);
/* extern int is_positive(int n);  ← 链接错误！is_positive 是 static */

int main(void) {
    print_sign(5);   /* + */
    print_sign(-3);  /* - */
    print_sign(0);   /* 0 */
    return 0;
}

🟡 练习 2：演示变量遮蔽

/* 写一个程序：
   - 声明全局变量 x = 100
   - 在一个函数内声明同名局部变量 x = 200
   - 在函数内外分别打印 x，观察遮蔽效应
   - 然后用另一个名字重新实现，避免遮蔽 */

#include <stdio.h>

int x = 100;  /* 全局变量 */

void demo_shadow(void) {
    int x = 200;  /* 遮蔽全局变量 */
    printf("inside (shadowed): x = %d\n", x);  /* 200 */
}

void demo_no_shadow(void) {
    int y = 200;  /* 使用不同的名字 */
    printf("inside (no shadow): global x = %d, y = %d\n", x, y);
}

int main(void) {
    printf("outside: x = %d\n", x);  /* 100 */
    demo_shadow();
    demo_no_shadow();
    printf("outside again: x = %d\n", x);  /* 100（没被改） */
    return 0;
}

🔴 练习 3：跨文件的前向声明

/* 创建两个 .c 文件和一个头文件：
   - mathlib.h：声明 add(int, int) 和 subtract(int, int)
   - mathlib.c：实现这两个函数（add 公开，subtract 用 static）
   - main.c：包含头文件，调用 add()；尝试调用 subtract() 观察效果 */

/* mathlib.h */
#ifndef MATHLIB_H
#define MATHLIB_H

int add(int a, int b);
int subtract(int a, int b);  /* 声明在这里，但实现是 static */

#endif

/* mathlib.c */
#include "mathlib.h"

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

static int subtract(int a, int b) {  /* static: 只有 mathlib.c 内部可见 */
    return a - b;
}

/* main.c */
#include <stdio.h>
#include "mathlib.h"

int main(void) {
    printf("add(3, 4) = %d\n", add(3, 4));
    /* printf("%d\n", subtract(7, 2));  ← 链接错误! */
    return 0;
}

故障排查（FAQ）

Q: "undefined reference" 是什么错误？

这是链接错误，不是编译错误。意思是：编译器找到了函数声明（所以编译通过了），但链接器在整个项目中找不到这个函数的定义（函数体）。

常见原因：

1. 函数名拼写错误（大小写不同也算）
2. 函数定义在另一个 .c 文件中，但你忘记把它加入编译
3. 函数被标记为 static，所以其他文件看不到它
4. 头文件声明了函数，但 .c 文件中没有实现

✅ 修复方法：

• 检查拼写（gcc 的错误信息会告诉你函数名）
• 确保所有 .c 文件都被编译（make 或 gcc *.c）
• 去掉 static 或改用公开函数间接调用

Q: 什么时候该用 static 函数？

原则：默认把辅助函数标为 static，只在需要跨文件调用时才去掉 static。

典型场景：

• 工具函数（字符串解析、数据校验、内部计算）—— 用 static
• 公开的 API 接口函数 —— 不用 static
• 两个 .c 文件需要同名辅助函数 —— 都用 static，不冲突

Q: static 函数和 static 变量是一回事吗？

不完全一样，但逻辑类似：

• static 变量（在函数内）：延长生命周期到整个程序
• static 变量（在文件级）：限制为内部链接，其他文件不可见
• static 函数：限制为内部链接，其他文件不可见

文件级的 static 变量和 static 函数含义相同——限制可见性。

Q: 前向声明和头文件有什么关系？

前向声明是一个概念：在函数定义之前先告诉编译器它的存在。头文件是承载前向声明的载体。

  前向声明（概念）
       │
       ▼
  头文件（载体）: .h 文件中放函数声明
       │
       ▼
  .c 文件（使用者）: #include ".h" 获得声明

Q: 可以把 static 函数声明在头文件中吗？

可以，但不推荐。static 意味着"每个包含这个头文件的 .c 文件都有自己的一份副本"，这通常不是你想要的效果。建议：static 函数直接在 .c 文件内部定义，不放头文件。

知识扩展（选学）

函数指针指向 static 函数

虽然 static 函数不能从其他文件直接调用，但你可以通过函数指针在文件内部间接调用它：

#include <stdio.h>

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

static int multiply(int a, int b) {
    return a * b;
}

/* 函数指针数组——两个 static 函数都能放入 */
int main(void) {
    int (*operations[2])(int, int) = {add, multiply};

    printf("add(3, 4)    = %d\n", operations[0](3, 4));
    printf("multiply(3, 4) = %d\n", operations[1](3, 4));
    return 0;
}

函数指针打破了"只能按名字调用"的限制——只要拿到函数指针，就能调用函数。但这个技巧只在同一个文件内有效（因为 static 函数的地址也无法被其他文件获取）。

extern "C" 与 C++ 混合编程

如果你在 C++ 项目中调用 C 函数，需要用 extern "C" 告诉 C++ 编译器使用 C 语言的链接方式（C++ 有名称修饰，C 没有）：

// C++ code
extern "C" {
    #include "my_c_lib.h"
}

这超出了纯 C 的范围，但作为扩展知识了解是有益的。

小结

函数作用域的核心规则可以浓缩为三条：

• 默认情况下，函数是公开的（外部链接）：其他文件可以通过前向声明调用它
• 加了 static，函数变成私有的（内部链接）：只有自己的 .c 文件能调用
• 前向声明是函数的"预告"：告诉编译器函数存在，定义可以在别处

你还学到了：

• 局部变量可以遮蔽全局变量（但这是反模式，应该避免）
• extern 关键字用于声明跨文件的函数/变量
• 头文件是管理前向声明的最佳载体，不要在手写 extern
• "undefined reference" 链接错误的常见原因和修复方法

我的理解：把函数作用域想象成权限管理——static 是最小权限原则，extern 是共享协作。好的代码应该是"该私有的私有，该公开的公开"，而不是所有函数都敞开门等着被调用。

术语表

延伸阅读

• cppreference: Scope and Linkage (C)
• cppreference: Functions in C
• Beej's Guide to C: Static and Global Variables
• K&R《C 程序设计语言》第 4.4、4.5 章

继续学习

你现在已经理解 C 语言中函数的"可见性规则"。在后续章节中，我们将继续深入作用域体系——头文件与模块系统，学习如何正确地组织多文件项目，通过头文件管理接口与实现的分离。

💡 提示：检查你的代码里所有函数：辅助函数是否标记了 static？头文件中的声明与 .c 文件中的定义是否一致？有没有遗漏的前向声明？

← 上一章：函数基础 | 下一章：作用域与生命周期 →

数组基础 (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 字节。

数组索引与地址计算:

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

偏移:  0    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   16   17   18   19
     ┌───────────────────┬───────────────────┬───────────────────┬───────────────────┬───────────────────┐
值:  │        10         │        20         │        30         │        40         │        50         │
     │      arr[0]       │      arr[1]       │      arr[2]       │      arr[3]       │      arr[4]       │
     └───────────────────┴───────────────────┴───────────────────┴───────────────────┴───────────────────┘

地址: base+0             base+4             base+8             base+12            base+16

  公式: &arr[i] = 起始地址 + i × sizeof(元素类型)
  sizeof(arr) = 5 × 4 = 20 字节

  危险区 (越界):
     ┌───────────────────┐
     │    arr[5]         │  ← 超出数组边界! 未定义行为
     │  (base + 20)      │     可能读到垃圾值或崩溃
     └───────────────────┘

三种初始化方式

// 方式 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> 中的内存操作函数
• 下一章: 预处理器与宏 — #include 展开、#define 替换

继续学习

预处理器与宏（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 参数指定的路径中查找

预处理流水线 (从 .c 到 .i 再到编译器):

  ┌──────────┐    ┌────────────────┐    ┌──────────┐    ┌──────────┐
  │ 源代码   │    │  预处理器      │    │ 中间文件  │    │ 编译器   │
  │ hello.c  │──→ │  (cpp)         │──→ │ hello.i   │──→ │ hello.o  │
  └──────────┘    └──────┬─────────┘    └──────────┘    └──────────┘
                         │
            ┌────────────┼────────────────┐
            │            │                │
            ▼            ▼                ▼
     ┌──────────┐  ┌──────────┐    ┌──────────┐
     │ #include │  │ #define  │    │ #ifdef   │
     │ 展开头文件│  │ 宏替换    │    │ 条件筛选  │
     └──────────┘  └──────────┘    └──────────┘

  预处理器只做文本操作 (不检查语法, 不理解语义)
  gcc -E hello.c 可以查看预处理后的 .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 替换它们。你会发现代码可读性立刻提升了！

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

条件编译（Conditional Compilation）

"一套代码，多套世界。" —— 在 C 语言中，我学会了用 #ifdef 写出适应不同平台的代码。

开篇故事

想象一位翻译。他面对讲中文的听众就用中文讲，面对讲英语的听众就用英语讲——同一个故事，不同语言。翻译不需要为每种语言写不同的演讲稿，他根据观众自动选择。

条件编译就是编译器的「翻译官」。同一份源代码，#ifdef __APPLE__ 告诉编译器：如果你在为 macOS 编译，就保留这段代码；#elif defined(__linux__) 说：如果你在为 Linux 编译，换另一段。#endif 是结束标记。不是运行时切换，是编译时就已经选好了。

你的源代码是一本「多语言剧本」，编译器决定最终演出哪一版。

本章适合谁

• 想写出跨平台 C 代码的开发者
• 对 #ifndef、#define、#ifdef 有基本了解，但不清楚实际应用场景

你会学到什么

1. #ifdef/#ifndef/#elif/#else/#endif 的完整用法
2. 平台检测宏（__APPLE__、__linux__、__FreeBSD__）
3. 功能测试宏（_GNU_SOURCE、_POSIX_C_SOURCE）
4. Debug vs Release 模式的条件编译
5. 常见的条件编译模式和陷阱

前置要求

完成"预处理器与宏"章节（了解 #define 机制）

第一个例子

#ifdef __APPLE__
    printf("Hello from macOS!\n");
#elif defined(__linux__)
    printf("Hello from Linux!\n");
#else
    printf("Hello from an unknown platform!\n");
#endif

完整源码

原理解析

条件编译是预处理器的核心功能之一。预处理器在编译之前扫描源码，根据条件决定保留哪些代码。

#ifdef / #ifndef / #elif / #else / #endif

#ifdef DEBUG
    printf("调试信息: x = %d\n", x);
#endif

#ifndef NDEBUG
    assert(x > 0);
#endif

#ifdef __APPLE__
    /* macOS 特有代码 */
#elif defined(__linux__)
    /* Linux 特有代码 */
#else
    /* 其他平台 */
#endif

条件编译决策树:

                    ┌──────────────┐
                    │  #ifdef X    │
                    └──────┬───────┘
                           │
          ┌────────────────┼────────────────┐
          │ X 已定义        │ X 未定义        │
          ▼                 ▼                 │
    ┌──────────┐     ┌──────────────┐        │
    │  代码段A  │     │  #elif Y     │        │
    └──────────┘     └──────┬───────┘        │
                   ┌────────┼────────┐       │
                   │ Y 已定义│ Y 未定义│       │
                   ▼        ▼        │       │
             ┌──────────┐ ┌──────┐   │       │
             │  代码段B  │ │ #else │   │       │
             └──────────┘ └──┬───┘   │       │
                             ▼       │       │
                       ┌──────────┐  │       │
                       │  代码段C  │  │       │
                       └──────────┘  │       │
                             │        │       │
                             └────────┴───────┘
                                        │
                                        ▼
                                  ┌──────────┐
                                  │  #endif  │
                                  └──────────┘

  未选中的代码在编译后完全不存在——不是在运行时跳过, 而是根本没被编译

平台检测宏

功能测试宏

/* 在 #include 之前定义 */
#define _GNU_SOURCE
#include <string.h>  /* 现在可以用 strcasecmp() 了 */

Debug vs Release

#ifndef NDEBUG
    /* Debug 模式: assert 启用 */
    assert(ptr != NULL);
#else
    /* Release 模式: assert 被替换为空 */
#endif

编译 Release 时加上 -DNDEBUG 标志即可禁用所有 assert()。

常见错误

❌ 错误 1: #ifdef 没有匹配的 #endif

#ifdef DEBUG
    printf("调试信息\n");
/* 忘记 #endif → 编译错误 */

编译器报错:

error: unterminated #ifdef

✅ 修复: 始终配对:

#ifdef DEBUG
    printf("调试信息\n");
#endif

❌ 错误 2: 拼写错误的宏名导致静默失败

#ifdef __APPLE__     /* 正确的 */
    mach_info();
#elif __LINUX__      /* 错误! 应该是 __linux__ (小写) */
    linux_info();    /* 永远不会执行 */
#endif
#endif

✅ 修复:

#elif defined(__linux__)
    linux_info();

❌ 错误 3: 缺少 fallback（#else 中无 #error）

#ifdef DEBUG
    verbose_log();
#elif defined(RELEASE)
    minimal_log();
#endif
/* 既不 DEBUG 也不 RELEASE 时，没有任何日志！*/

✅ 修复:

#ifdef DEBUG
    verbose_log();
#elif defined(RELEASE)
    minimal_log();
#else
    #error "Unknown build type! Define DEBUG or RELEASE"
#endif

动手练习

🟢 入门: 平台检测

编写代码，在 macOS 上打印 "Darwin"，在 Linux 上打印 "Linux"，其他平台打印 "Other"。

#if defined(__APPLE__)
    printf("Darwin\n");
#elif defined(__linux__)
    printf("Linux\n");
#else
    printf("Other\n");
#endif

🟡 中级: Debug/Release 日志

实现一个日志宏，在 Debug 模式下打印文件名+行号+消息，在 Release 模式下只打印消息。

#ifndef NDEBUG
    #define LOG(msg) printf("[%s:%d] %s\n", __FILE__, __LINE__, msg)
#else
    #define LOG(msg) printf("%s\n", msg)
#endif

🔴 挑战: 多平台系统信息

编写一个函数，在 macOS 上显示 Mach kernel info，在 Linux 上显示 /proc/version，在未知平台显示 "unsupported"。使用条件编译处理不同的 #include 和不同的实现路径。

void show_system_info(void) {
#if defined(__APPLE__)
    /* macOS: 使用 sysctlbyname */
    char os_version[256];
    size_t len = sizeof(os_version);
    sysctlbyname("kern.osversion", os_version, &len, NULL, 0);
    printf("macOS version: %s\n", os_version);
#elif defined(__linux__)
    #include <sys/utsname.h>
    struct utsname info;
    uname(&info);
    printf("Linux kernel: %s\n", info.release);
#else
    printf("系统信息: 不支持的平台\n");
#endif
}

故障排查 (FAQ)

Q: #ifdef 和 #if defined() 有什么区别？

A: #ifdef MACRO 检查单个宏是否定义。#if defined(MACRO) 可以组合使用：#if defined(A) && defined(B)。对于复杂条件，推荐用 #if defined().

Q: #pragma once 和 include guards 哪个好？

A: #pragma once 更简洁，但某些编译器可能不支持（虽然主流都支持）。推荐两者同时使用：

#pragma once
#ifndef MY_HEADER_H
#define MY_HEADER_H
/* ... */
#endif

Q: 条件编译会影响运行性能吗？

A: 不会。条件编译在编译前处理，编译器只会看到被保留的代码。未匹配的分支在编译后的二进制中完全不存在。

知识扩展 (选学)

Feature Test Macros: POSIX 标准

GNU/Linux 上的 <features.h> 头文件定义了整个 POSIX 标准的 API 可见性：

/* C99 标准 */
#define _POSIX_C_SOURCE 200809L
#include <unistd.h>

/* GNU 扩展 */
#define _GNU_SOURCE
#include <string.h> /* strcasestr, asprintf 等 */

编译器预定义宏

C 编译器预定义了许多有用的宏:

• __FILE__ — 当前文件名 (字符串)
• __LINE__ — 当前行号 (整数)
• __func__ — 当前函数名 (C99, 字符串)
• __DATE__ — 编译日期 (字符串, "Mon DD YYYY")
• __TIME__ — 编译时间 (字符串, "HH:MM:SS")

小结

核心要点:

1. #ifdef/#ifndef/#elif/#else/#endif 用于编译时条件选择
2. 平台检测宏（__APPLE__、__linux__）用于跨平台代码
3. _GNU_SOURCE、_POSIX_C_SOURCE 控制 API 可见性
4. 始终在 #else 中使用 #error 覆盖未知情况

关键术语: 条件编译 → 预处理器根据条件决定保留哪些代码 → 不同于运行时的 if/else

术语表

延伸阅读

• GNU CPP Manual: Conditionals — 官方条件编译文档
• Predefined C/C++ Compiler Macros — 列出所有编译器预定义宏
• sysinfo.c in this project — 本项目中的跨平台系统信息完整示例

继续学习

← 位运算与内存操作 | 函数指针 →

枚举（Enums）

"枚举是给整数起了名字，是'只能选一个'的承诺。" —— 我发现

开篇故事

想象墙上有一盏灯，旁边有个开关。这个开关只有两档：ON 和 OFF。你不会用「随便拧到一个角度」来控制它——它只能取其中的一个状态，不能同时又是开又是关。

枚举就是程序里的电灯开关。它定义了一组有限的、互斥的选项，每次只能选一个。

enum LightState { OFF, DIM, BRIGHT };
enum LightState lamp = DIM;  // 当前只有一个状态
// lamp 不可能同时是 OFF 和 BRIGHT

在枚举出现之前，程序员用 #define 来定义状态码。宏也能工作，但它没有任何类型保护——set_state(999) 能通过编译，因为 999 也是一个合法的整数。枚举引入了类型检查的语义约束，让「传入非法状态」这件事在代码层面变得更明显。

"枚举的本质不是数字，而是'只能选一个'的承诺。"

本章适合谁

• 用过 #define 定义状态码，但踩过类型安全坑的人
• 对 Rust enum、Python Enum 有了解，想对比 C 的枚举

你会学到什么

• enum 的定义、使用与底层原理
• 枚举与 #define 常量的对比与选择
• 枚举值的显式赋值与自动递增
• 将枚举作为函数参数和返回值
• 枚举的边界验证与错误处理
• 实际应用：状态机、错误码、配置选项

前置要求

• 了解基本的 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";
    }
}

实际应用：错误码模式

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：枚举更安全、可调试、支持自动递增
• 枚举验证：永远用 switch + default 覆盖所有枚举值，防止非法值
• 位标志：枚举可以用位移值做组合操作
• 枚举的边界：C 允许给枚举赋任意 int，运行时需验证

我的理解：枚举不是银弹——它提供了更好的表达力，但不像 Rust 的 enum 那样严格。理解它既是"命名的整数"也是"带标签的类型"，你就能在安全和效率之间找到最佳平衡。

术语表

延伸阅读

• cppreference: Enum types (C)
• K&R《C 程序设计语言》第 1.6 章
• 《C Primer Plus》第 11 章：结构体和枚举

继续学习

枚举让你掌握了 C 语言中标识多种状态的基础。下一章我们将深入学习联合体（Union）——理解多类型如何共享同一块内存。

💡 提示：检查你的代码里所有 #define 定义的状态码，尝试替换为 enum。你会发现代码的可读性和安全性都提升了！

← 上一章：指针运算 | 下一章：联合体 →

typedef（类型别名）

给类型起个外号，让你少打几个字。

开篇故事

每次写 C 代码，我都要在 struct 前面加 struct——struct Student s; struct Rectangle r;。这就像每次叫人名字前都要说"先生"——"张先生你好，李先生再见"——礼貌过头了。

typedef 就是给类型起外号。一次定义，以后直接用。Student s; 比 struct Student s; 简洁多了。

我第一次用 typedef 是因为看 Linux 内核代码——内核里几乎看不到裸的 struct，全是 struct task_struct *current 这种。后来发现 typedef 在函数指针里才是真正的救星：typedef int (*CompareFn)(const void *, const void *);，没有它写出来的声明像天书。

"typedef 不是创建新类型，而是给已有类型起个好记的外号。"

本章适合谁

• 已经会定义和使用结构体
• 觉得 struct StructName 太繁琐的 C 学习者
• 想理解函数指针声明的读者

你会学到什么

• typedef 的基本语法和语义
• typedef struct 简化结构体声明
• typedef 用于数组和指针
• 函数指针 typedef（简化复杂声明）
• Callback 模式的 typedef 实践

前置要求

• 完成 结构体内存布局 章节
• 理解 函数 的基本概念

第一个例子

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

typedef struct Student {
    char name[32];
    int32_t age;
} Student;

/* 现在可以这样声明： */
Student s = { .name = "Alice", .age = 20 };

int main(void) {
    printf("%s, age %" PRId32 "\n", s.name, s.age);
    return 0;
}

不需要写 struct Student s——直接 Student s。少打了 7 个字符，但更关键的是代码意图更清晰。

原理解析

1. typedef 的本质

typedef int32_t Age;

Age a = 20;    /* 等价于 int32_t a = 20; */

typedef 不创建新类型，只是给已有类型加了一个"别名"。编译器眼里 Age 和 int32_t 完全一样。

typedef 别名映射关系:

  原始类型               typedef 别名            使用方式
  ┌──────────────┐     ┌──────────┐          ┌────────────────┐
  │ int32_t      │────→│ Age      │─────────→│ Age a = 20;    │
  └──────────────┘     └──────────┘          └────────────────┘

  ┌──────────────┐     ┌──────────┐          ┌──────────────────┐
  │ struct       │────→│ Student  │─────────→│ Student s;      │
  │ Student      │     └──────────┘          └──────────────────┘
  └──────────────┘

  ┌──────────────┐     ┌──────────┐          ┌──────────────────┐
  │ int32_t (*)  │────→│ BinaryOp │─────────→│ BinaryOp fp;    │
  │ (int32_t,    │     └──────────┘          └──────────────────┘
  │  int32_t)    │
  └──────────────┘

编译器视角:
  typedef 只是别名(alias), 不创建新类型
  sizeof(Age) == sizeof(int32_t) == 4  ✅

2. typedef + struct

/* 传统写法 */
struct Student { char name[32]; int32_t age; };
struct Student s;  /* 必须写 struct */

/* typedef 写法 */
typedef struct Student {
    char name[32];
    int32_t age;
} Student;
Student s;  /* 不需要 struct 前缀 */

这是 C 项目中最常见的 typedef 用法。C++ 不需要——C++ 的 struct 名自动成为类型名。

Python 的 class/实例          C struct + typedef
─────────────────           ─────────────────
class Student:                typedef struct Student { ... } Student;
    pass                      Student s;  ← 简洁声明
s = Student()                 s = (Student){ .name = "A" };

3. Python dict vs C typedef 对比

C typedef + struct:
  Student s;                    ← 编译期解析为 struct Student
  s.name = "Alice";             ← 直接内存偏移，零运行时开销

Python dict:
  s = {"name": "Alice"}          ← 创建 dict 对象 + hash table
  s["name"]                      ← 哈希查找 "name" → 返回值

4. typedef 用于数组和指针

typedef int32_t IntArray10[10];   /* IntArray10 是 "含10个int32_t的数组" */
typedef char *StringPtr;          /* StringPtr 是 char* 的别名 */

IntArray10 arr;    /* 等价于 int32_t arr[10]; */
StringPtr greeting = "hello";     /* 等价于 char *greeting = "hello"; */

5. 函数指针 typedef

/* 没有 typedef: 天书 */
int32_t (*fp)(int32_t, int32_t) = &add;

/* 用 typedef: 清晰 */
typedef int32_t (*BinaryOp)(int32_t, int32_t);
BinaryOp fp = &add;

/* 作为函数参数 */
int32_t apply(BinaryOp op, int32_t x, int32_t y) {
    return op(x, y);
}

我发现：函数指针不加 typedef 几乎不可读。加 typedef 后，意图一目了然。

6. Callback 模式

typedef void (*Visitor)(int32_t index, int32_t value, void *context);

void traverse(int32_t data[], int32_t len, Visitor visit, void *ctx) {
    for (int32_t i = 0; i < len; i++) {
        visit(i, data[i], ctx);
    }
}

这是 C 语言实现"遍历框架 + 自定义回调"的标准模式——类似于 Python 的 for item in iterable: callback(item)。

常见错误（Error-First）

❌ 错误 1: typedef 不是新类型

typedef int32_t Age;
Age a = 20;
int32_t b = a;  /* ✅ 编译完全一致 — Age 就是 int32_t */

如果你想要"类型安全"的 Age（不允许和 int 混用），typedef 做不到——你要么用 struct 包装，要么用 Rust。

❌ 错误 2: typedef 位置导致误解

typedef char *StringPtr;
StringPtr p1, p2;  /* ✅ 两个都是 char* */

char *p3, p4;      /* ⚠️ p3 是 char*, p4 是 char！ */

用 typedef 可以避免这种常见的 C 陷阱。

动手练习

typedef bool (*Predicate)(int32_t value);
int32_t filter(int32_t data[], int32_t len, Predicate pred, int32_t out[]);

故障排查（FAQ）

#define IntPtr int*
IntPtr a, b;  /* 展开为: int* a, b; → b 是 int，不是 int*! */

typedef int *IntPtr;
IntPtr a, b;  /* ✅ a 和 b 都是 int* */

知识扩展

复杂声明的阅读方法：螺旋法则

void (*signal(int, void (*)(int)))(int);
   └─── 最内层 ─┘
   signal 是函数，参数是 int 和 void(*)(int)，返回 void(*)(int)

用 typedef 简化:
typedef void (*SigHandler)(int);
SigHandler signal(int, SigHandler);  /* 清晰多了 */

小结

• typedef 给类型起别名，不创建新类型
• typedef struct 是最常见用法：省去 struct 前缀
• 函数指针 typedef 大幅简化声明
• Callback 模式依赖 typedef 建立清晰接口
• typedef 比 #define 类型安全得多

术语表

延伸阅读

• cppreference: Typedef
• K&R《C 程序设计语言》§5.11: Typedef
• The "Clockwise Rule"

继续学习

指针 (Pointers)

开篇故事

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

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

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

什么是指针

指针是 C 语言中最核心也最让人迷惑的概念。但从根本上说，它很简单：指针就是一个存储内存地址的变量。

普通变量存的是值——int x = 42 表示 x 这个盒子里装着 42。指针变量存的是地址——int *p = &x 表示 p 这个盒子里装着 x 的位置。这就是全部。

为什么需要指针？因为 C 语言默认是值传递的。当你把一个变量传给函数时，函数拿到的是副本，不是原件。指针给了你一种方式：「这是我的数据的地址，你直接去那里操作。」这让函数可以修改调用方的变量，也让程序可以动态管理内存。

当然，指针是一把双刃剑。用对了，它让程序高效、灵活；用错了，它会带来段错误、野指针、内存泄漏。每个 C 程序员都经历过这些痛苦。好消息是：规则不多，理解之后你就能驾驭它。

最简单的例子

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

int main(void) {
    int32_t  num = 42;
    int32_t *ptr = &num;   // ptr 存储 num 的地址

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

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

    return 0;
}

这个例子展示了指针的三个核心操作：声明（int32_t *ptr）、取地址（&num）、解引用（*ptr）。

你会学到什么

指针是一个大家族，各个子章节深入探讨不同的侧面：

• 指针基础 — &、*、NULL、初始化、野指针，从零掌握指针的核心语法
• 指针运算 — 指针加减、数组等价性，理解指针如何在内存中移动
• void* 类型擦除 — 万能指针与类型擦除，类型安全与泛型编程
• 指针与数组 — 多维数组、数组下标本质，打通指针和数组的关系
• 指针与函数 — 指针参数、返回指针，用指针实现引用语义
• const 正确性 — const 指针、指针到 const，在类型系统中表达约束

建议按顺序学习，因为每个子章节建立在前一个的基础之上。

继续学习

• 上一章：数据类型
• 下一章：指针基础——从 & 和 * 开始

指针基础 (&, *, NULL, 初始化)

开篇故事

指针像 GPS 坐标——它不是目的地，而是告诉你目的地的方向。

想象你在一个陌生的城市旅行。你不需要亲自走到每一条街上，你只需要一个坐标——经度和纬度。输入坐标，导航就会带你到达。指针在 C 语言中做的事情完全一样：它不存储数据本身，它存储的是数据在内存中的"坐标"。

int32_t destination = 42;      // 目的地本身
int32_t *gps = &destination;   // 指向目的地的坐标
int32_t value = *gps;          // 顺着坐标找到目的地，取出值 = 42

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

本章适合谁

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

你会学到什么

1. & 取地址运算符和 * 解引用运算符的本质含义
2. 指针声明语法：int32_t *p 中 * 属于变量而非类型
3. NULL 指针的含义、 dangers 以及安全检查模式
4. 如何正确初始化指针，彻底杜绝野指针 (Dangling Pointer)
5. 指针类型如何决定编译器解释内存的方式
6. Python 变量赋值 vs C 指针赋值的认知对照

前置要求

• 已完成 变量 和 数据类型 章节
• 理解变量是内存中的命名存储空间
• 理解 <stdint.h> 中的固定宽度类型（int32_t、int64_t 等）

第一个例子

最简短的指针演示程序——声明一个变量和指向它的指针：

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

int main(void) {
    int32_t  num = 42;
    int32_t *ptr = &num;   // ptr 存储 num 的「GPS 坐标」

    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;            // 顺着 GPS 坐标修改目的地
    printf("修改 *ptr 后, num = %d\n", num);

    return 0;
}

编译运行：

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

输出：

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

这段代码揭示了 C 指针的核心模式：

• &num → 获取 num 的地址（GPS 坐标）
• int32_t *ptr → 声明一个「指向 int32_t」的指针变量
• *ptr → 解引用：顺着坐标找到 num，读取或修改它的值

原理解析

1. & 取地址：获取变量的 GPS 坐标

每一个变量在内存中都有一个确定的地址。& 运算符返回这个地址：

int32_t x = 42;
printf("%p\n", (void *)&x);  // 打印 x 在内存中的地址

(void *) 转换是因为 %p 格式说明符要求 void* 类型参数。

2. * 解引用：顺着坐标找到数据

* 运算符「跟随」指针中的地址，访问那个地址上的数据：

int32_t x = 42;
int32_t *p = &x;

printf("%d\n", *p);   // 42 — 顺着 p 找到 x
*p = 99;              // 修改 p 指向的数据 → x 变成 99

3. 内存布局 ASCII 图

理解指针最直观的方式是看内存图：

  栈内存 (Stack Memory)

  ┌──────────────────────────────┐
  │ 符号    │ 地址       │ 值      │
  ├──────────────────────────────┤
  │ x       │ 0x7ff…b0   │ 42      │  ← 实际数据
  │ p       │ 0x7ff…b8   │ 0x7ff…b0 │  ← 指针存 x 的地址
  └──────────────────────────────┘
                         │
                    *p → ┘  解引用: 取出 p 的值 (0x7ff…b0)，
                         再到那个地址取值 → 42

关键认知：

• x 在 0x7ff…b0，存放数值 42
• p 在 0x7ff…b8，存放的是 0x7ff…b0（&x）
• *p = 取出 p 中的地址 → 到那个地址取值 = 42
• &p = p 自己的地址 = 0x7ff…b8（指针本身也有地址！）

4. NULL 指针与安全检查

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

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

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

正确模式：使用前检查

int32_t target = 42;
int32_t *ptr = NULL;

/* 某个操作可能给 ptr 赋值 */
ptr = ⌖

if (ptr != NULL) {
    printf("%d\n", *ptr);  /* ✅ 安全 */
} else {
    printf("ptr 尚未初始化\n");
}

5. 指针初始化——拒绝野指针

野指针 (Dangling Pointer) 是最常见的指针错误：

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

两种安全的初始化方式：

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

黄金法则：声明指针时必须初始化——要么指向确定的地址，要么初始化为 NULL。

6. 指针类型决定步长

指针的类型告诉编译器两件事：解引用时读多少字节，指针加法时前进多少字节。

int32_t  iv = 0x01020304;
int32_t *pi = &iv;    /* pi 每次 +1 前进 4 字节 */
uint8_t *pb = (uint8_t *)&iv;  /* pb 每次 +1 前进 1 字节 */

常见错误

❌ 错误 1：解引用未初始化的指针

int32_t *p;      /* 未初始化 */
*p = 42;         /* ❌ 写入随机内存! */

编译器可能报 uninitialized 警告，但运行时会段错误或产生隐蔽的数据损坏。

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

❌ 错误 2：解引用 NULL

int32_t *p = NULL;
printf("%d\n", *p);   /* ❌ 段错误! */

/* ✅ 修复：检查 NULL */
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 */
printf("%d\n", a);   /* a 还是 10! 没被修改 */

/* ✅ 如果想通过指针修改 a 的值 */
int32_t *p = &a;
*p = 20;   /* *p = a，现在 a = 20 */

动手练习

🟢 入门：GPS 导航——用指针读取和修改

声明 int32_t x = 100，创建指针 p 指向它，用 *p 把值改为 200，打印验证 x 已被修改。

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

int main(void) {
    int32_t x = 100;
    int32_t *p = &x;

    printf("修改前: x = %" PRId32 ", *p = %" PRId32 "\n", x, *p);
    *p = 200;
    printf("修改后: x = %" PRId32 ", *p = %" PRId32 "\n", x, *p);
    return 0;
}

修改前: x = 100, *p = 100
修改后: x = 200, *p = 200

🟡 中级：NULL 防御式编程

编写一个函数 int safe_read(int32_t *p, int32_t *out)，当 p 为 NULL 时返回 0，否则将 *p 复制到 out 并返回 1。

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

int safe_read(int32_t *p, int32_t *out)
{
    if (p == NULL) return 0;
    if (out == NULL) return 0;
    *out = *p;
    return 1;
}

int main(void) {
    int32_t val = 42;
    int32_t result = 0;

    if (safe_read(&val, &result)) {
        printf("读取成功: %" PRId32 "\n", result);
    }
    if (!safe_read(NULL, &result)) {
        printf("NULL 指针安全拦截\n");
    }
    return 0;
}

🔴 挑战：追踪指针轨迹

声明三个变量 a = 1, b = 2, c = 3，用指针 p 依次指向它们，每次指向后用 *p 打印值。最后用二级指针 pp 指向 p，通过 **pp 获取值。

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

int main(void) {
    int32_t a = 1, b = 2, c = 3;
    int32_t *p = &a;

    printf("*p (指向 a) = %" PRId32 "\n", *p);
    p = &b;
    printf("*p (指向 b) = %" PRId32 "\n", *p);
    p = &c;
    printf("*p (指向 c) = %" PRId32 "\n", *p);

    int32_t **pp = &p;
    printf("**pp = %" PRId32 " (通过二级指针间接获取)\n", **pp);
    return 0;
}

故障排查 (FAQ)

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

A：对！这是 C 最著名的混淆点：

• int *p;声明：* 表示 p 是「指向 int 的指针」类型
• *p = 10;使用：* 是解引用运算符——找到 p 指向的变量，赋值 10

一个是类型标记，一个是运行时操作。

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

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

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

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

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

A：指针类型决定了：

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

void* 没有类型信息，不能直接 *vp 解引用。

知识扩展

指向指针的指针 (二级指针)

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

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

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

常见场景：

• 函数返回多个值（如 scanf("%d", &x) 里的 &x）
• 动态二维数组（char** argv 命令行参数）
• 修改指针本身（而非它指向的值）

内存地址的可视化

  堆栈布局 (64 位系统)

  高地址 ┌──────────────┐
        │  main 帧        │
        │  value = 42     │  0x7ff...a0
        │  ptr = 0x7ff…a0 │  0x7ff...a8  ← 8 字节
        │  pp  = 0x7ff…a8 │  0x7ff...b0  ← 8 字节
  低地址 └──────────────┘

  sizeof(int32_t*) = 8  (64 位指针)
  sizeof(int32_t)  = 4

小结

• 指针是存储内存地址的变量，类型为 T*
• & 取地址运算符，返回变量地址
• * 解引用运算符，通过地址访问值
• NULL 指针表示无效地址，使用前必须检查
• 野指针（未初始化）是危险的——始终初始化为有效地址或 NULL
• 指针类型决定解引用范围和步长

术语表

延伸阅读

• cppreference - Pointers — 指针类型和操作参考
• C17 标准 §6.5.3.2 — 解引用运算符

继续学习

• 上一章：数据类型
• 下一章：指针运算——数组等价性、指针算术

本章代码位于 src/basic/pointer_basics_sample.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> 中的标准类型
• 下一章：void* 类型擦除 —— 万能指针与字节级操作

继续学习

void* 指针 (Void Pointers)

开篇故事

想象一个万能充电适配器——能插美标、欧标、英标的插座，因为插头是通用的。但连上设备后，你必须知道那台设备需要多少伏特。适配器接错了电压会烧设备——void* 转错了类型，数据就乱套。

void* 就是 C 的万能指针，可以指向任何类型。但读之前，必须转回正确类型。

本章适合谁

• 已掌握具体类型指针（int*、char*）
• 正在读标准库函数（qsort、bsearch、memset）源码
• 想了解 C 语言如何实现"通用指针"

你会学到什么

• void* 的本质——无类型指针
• 安全转换回具体类型（*(int32_t *)vp）
• const void* 的用法
• 为什么 void* 不能做指针算术
• 与 Python/C++ 泛型的认知对照

🔥 下一步: void* 泛型编程 — 学习如何用 void* 设计泛型函数、Type Tag 模式、qsort 回调机制、C11 _Generic 等进阶内容。

前置要求

• 已完成 指针运算

第一个例子

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

int main(void) {
    int32_t i = 42;
    double  d = 3.14;
    char    c = 'Z';

    void *vp1 = &i;  /* void* 接收 int32_t*，无需强转 */
    void *vp2 = &d;
    void *vp3 = &c;

    /* ⚠️ 读取前必须先转回正确类型 */
    printf("i = %" PRId32 "\n", *(int32_t *)vp1);
    printf("d = %.2f\n",   *(double *)vp2);
    printf("c = '%c'\n",   *(char *)vp3);

    return 0;
}

两条核心规则：

• void* 可以接收任何类型地址（编译器内置隐式转换）
• void* 不能直接解引用——必须先 (type *) 转回具体类型

原理解析

1. void* 的本质

void 表示「无类型」，void* 因此被称为通用指针 (universal pointer)。

内存中 void* 和 int32_t*、char* 完全一样——都是 8 字节地址。区别在于编译器如何看待它：

2. 转回具体类型

int32_t value = 42;
void *vp = &value;

/* ✅ 正确: 先转为 int32_t*，再解引用 */
int32_t recovered = *(int32_t *)vp;

/* ❌ 错误: 直接解引用 void* */
/* int32_t bad = *vp; */
/* error: invalid use of undefined type 'void' */

类比：void* 像拆了标签的快递盒。必须先贴标签（类型转换），才能打开。

3. const void*

const void* 指向只读数据——保证不会被修改：

void print_data(const void *data, size_t size) {
    /* 只能读，不能修改 data 指向的内容 */
}

qsort 的比较函数用 const void*——保证排序不会修改元素：

int cmp_int(const void *a, const void *b);

常见错误

❌ 错误 1：直接解引用 void*

void *vp = &x;
int n = *vp;   /* ❌ 编译错误 */

/* ✅ 修正 */
int n = *(int32_t *)vp;

❌ 错误 2：转回错误类型（运行时 UB）

double d = 3.14;
void *vp = &d;
int n = *(int32_t *)vp;  /* ❌ 编译通过，数据全错！*/

最危险的 void 错误*——编译器不警告，但读出的数据完全错误。

❌ 错误 3：void* 指针算术

void *vp = buf;
vp++;  /* ❌ 标准 C 无定义！编译器不知道 void 的大小 */

/* ✅ 修正：转成 unsigned char* 再运算 */
unsigned char *cp = (unsigned char *)vp;
cp++;   /* 前进 1 字节 */

动手练习

🟢 入门：void* 赋值与转换

声明 int32_t、double 和 char 变量，用 void* 分别指向它们，正确转换回原类型并打印。

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

int main(void) {
    int32_t i = 100;
    double  d = 2.718;
    char    c = 'X';
    void *vp;

    vp = &i;
    printf("int:    %" PRId32 "\n", *(int32_t *)vp);

    vp = &d;
    printf("double: %.3f\n", *(double *)vp);

    vp = &c;
    printf("char:   '%c'\n", *(char *)vp);

    return 0;
}

故障排查 (FAQ)

Q：为什么不用 uintptr_t 代替 void*？

A：uintptr_t 是整数类型，不能直接解引用。void* 的价值是「可间接寻址 + 类型擦除」——你总需要在某个时刻把它转回具体类型来读写数据。

Q：void* 能和 NULL 比较吗？

A：可以。void* 支持所有指针比较运算：

void *vp = NULL;
if (vp == NULL) { /* ... */ }  /* ✅ */

小结

• void* 是无类型指针, 可接收任何对象地址
• 不能直接解引用——必须先转回具体类型 (type *)
• 不能做指针算术——先转成 unsigned char*
• 隐式转换——任何指针赋给 void* 不需要强转

术语表

延伸阅读

• cppreference - Void pointer — void* 操作参考

继续学习

你已经掌握了 void* 指针的核心概念。下一步，我们将学习如何用 void* 设计泛型函数——这是 qsort、bsearch 等标准库 API 的设计原理。

• 上一章：指针运算——数组等价性、指针算术
• 下一章：void* 泛型编程——Type Tag、qsort 模式、C11 _Generic

本章代码位于 src/basic/void_pointers_sample.c。

指针与数组 (Pointers and Arrays)

开篇故事

想象一条笔直的街道，两旁是一排完全相同的 houses。每栋房子有一个门牌号（从 0 开始）。你知道第一栋的地址后，任何一栋的位置都可以通过简单加法算出来。

这正是 C 语言中数组与指针的关系。数组是连续的内存格子，指针是进入这条街道的入口。一旦你站在入口处，arr[i] 本质上就是「从入口前进 i 步后开门看里面的内容」——在 C 的底层，这等同于 *(arr + i)。

int32_t arr[4] = {10, 20, 30, 40};
int32_t *p = arr;    // p 站在街道上 (arr[0] 的位置)

arr[2]      // 开门牌号 2 的房子 → 30
*(p + 2)    // 从 p 前进 2 步，开门 → 30 (完全等价！)

理解了这个等价性，你就打通了 C 语言最核心的任督二脉。

本章适合谁

• 已掌握指针基础（&、*、NULL）
• 刚学完数组，好奇「数组名是不是指针」
• 被数组越界和 sizeof 陷阱坑过的程序员
• 想理解 C 为什么比 Python 快的底层原因

你会学到什么

1. arr[i] 与 *(arr + i) 的等价关系——C 语言底层真相
2. 数组名退化为指针的规则和边界
3. sizeof 在数组 vs 指针上的致命差异（最频繁踩坑）
4. 用指针遍历数组（for (p = arr; p < end; p++)）
5. 二维数组的行优先内存布局
6. i[arr] == arr[i]——指针算术的可交换性
7. Python 列表索引 vs C 指针遍历对比

前置要求

• 已完成 指针基础 和 数组 章节
• 理解数组是连续内存，索引从 0 开始
• 理解 sizeof(array) / sizeof(element) 计算元素个数

⚠️ 知识陷阱预警：数组名不是指针！

很多人第一次学 C 时会听到"数组名就是指针"这句话。这是不准确的——很多 C 教程都会犯这个错。

• 数组名代表整个数组。sizeof(arr) 返回整个数组大小（4 个 int = 16 字节）。
• 指针只是一个存储地址的变量。sizeof(p) 永远返回指针自身大小（64 位系统上 = 8 字节）。
• 当数组作为函数参数传递、或赋值给指针时，数组名退化为指针。这只发生在特定上下文中。

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

sizeof(arr);  // = 16 (4 × 4) — ✅ 编译器知道整个数组
sizeof(p);    // = 8      — ❌ 只知道指针自身大小

/* ✅ 正确：在数组定义处计算长度 */
size_t len = sizeof(arr) / sizeof(arr[0]);  // = 4

/* ❌ 错误：传给函数后数组名退化为指针，sizeof 失效 */
void process(int32_t *data) {
    size_t n = sizeof(data) / sizeof(data[0]);  // = 2 (错！应该是 4)
}

记住：数组名在大多数表达式中"退化为指针"，但 sizeof 是唯一能区分它们的上下文。

另外，C99 引入了变长数组 (VLA)，sizeof(vla) 在运行时计算——这与普通数组在编译期计算不同。VLA 不能初始化，也不能在结构体中使用。

第一个例子

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

int main(void) {
    int32_t arr[4] = {10, 20, 30, 40};

    /* 索引写法 */
    printf("arr[2]     = %d\n", arr[2]);

    /* 指针写法——完全等价 */
    printf("*(arr + 2) = %d\n", *(arr + 2));

    /* 地址也相同 */
    printf("&arr[1]    = %p\n", (void *)&arr[1]);
    printf("arr + 1    = %p\n", (void *)(arr + 1));

    return 0;
}

输出：

arr[2]     = 30
*(arr + 2) = 30
&arr[1]    = 0x7ffee4c4a3a4
arr + 1    = 0x7ffee4c4a3a4

核心发现：arr[i] 和 *(arr + i) 产生的机器码完全一样。编译器在背后做了同一件事。

原理解析

1. arr[i] ≡ *(arr + i) —— 底层等价

C 标准明确规定：a[e] 等价于 (*((a) + (e)))。

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

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

  arr[2]     → *(arr + 2) → 找到第三个元素 → 21 (十进制 33, 十六进制 0x15)
  *(2 + arr) → 同样的计算，结果相同
  2[arr]     → 居然合法！因为加法可交换

2. 数组名 vs 指针——关键区别

数组名是不可修改的地址常量，指针是可重赋值的变量：

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

/* 指针可以重新赋值 */
p = arr + 2;   /* ✅ p 现在指向 arr[2] */

/* 数组名不能赋值 */
arr = p;       /* ❌ 编译错误: 数组名是常量，不可修改 */

3. sizeof 陷阱——数组 vs 指针

这是学到指针时最多人踩的坑：

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

sizeof(data)    // = 32  (8 × 4 字节)
sizeof(ptr)     // = 8   (指针自身大小，不是数组!)

sizeof(data[0]) // = 4
sizeof(*ptr)    // = 4

// 计算元素个数
sizeof(data) / sizeof(data[0])  // = 32/4 = 8 ✅
sizeof(ptr) / sizeof(*ptr)      // = 8/4 = 2  ❌ 错误!

黄金法则：一旦数组被赋值给指针（或传给函数），sizeof 再也无法知道原始数组大小。

4. 用指针遍历数组

int32_t nums[5] = {10, 20, 30, 40, 50};
int32_t *p = nums;
int32_t *end = nums + 5;    /* end 指向数组末尾之后——合法! */

/* 索引法 */
for (int32_t i = 0; i < 5; i++) {
    printf("%d ", nums[i]);
}

/* 指针法 */
for (int32_t *q = p; q < end; q++) {
    printf("%d ", *q);
}

两种写法在现代编译器优化后生成相同的汇编代码。指针写法是风格偏好，不是性能优势。

5. 二维数组——行优先连续内存

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

C 的二维数组在内存中是一行接一行的连续块：

  内存布局:
  [1][2][3][4][5][6]
   ← row 0 →← row 1 →

  matrix[row][col] 与 *( *(matrix + row) + col ) 完全等价

二维数组名 matrix 的类型是 int32_t (*)[3]（指向包含 3 个元素的数组的指针），不是 int32_t **。

常见误区：

int32_t matrix[2][3];
int32_t **pp = matrix;   /* ❌ 类型不匹配! */
int32_t (*pa)[3] = matrix; /* ✅ 正确: pa 指向一个长度为 3 的数组 */

6. Python 列表 vs C 数组指针对比

Python 替你做好了所有安全检查，C 把选择权（和责任）交给你。

常见错误

❌ 错误 1：sizeof 数组退化后求长度

void process(int32_t *data) {
    /* ❌ 在函数内 sizeof 得到的是指针大小 */
    size_t len = sizeof(data) / sizeof(data[0]);  // = 8/4 = 2
}

int32_t arr[10] = {0};
process(arr);  /* arr 退化为 int32_t* */

/* ✅ 修复: 把长度作为参数传入 */
void process(int32_t *data, size_t len) {
    for (size_t i = 0; i < len; i++) {
        /* 安全遍历 */
    }
}

❌ 错误 2：混淆二维数组和指针的指针

int32_t matrix[3][3];
int32_t **p = matrix;  /* ❌ matrix 不是 int32_t** */

/* ✅ 正确 */
int32_t (*p)[3] = matrix;   /* p 指向「包含 3 个 int32_t 的数组」 */
/* 或 */
int32_t *flat = &matrix[0][0];  /* 展平为一维指针 */

❌ 错误 3：越界指针解引用

int32_t arr[4] = {1, 2, 3, 4};
int32_t *p = arr;

p = p + 5;    /* 越界 beyond (arr+4 是合法的，arr+5 不是) */
*p = 99;      /* ❌ 未定义行为 */

/* ✅ 始终用 end 指针控制范围 */
int32_t *end = arr + 4;
for (int32_t *p = arr; p < end; p++) {
    *p = 0;   /* 安全 */
}

动手练习

🟢 入门：索引 vs 指针对照

用两种方式打印 {10, 20, 30, 40, 50}：先用 arr[i]，再用 *(arr + i)，验证结果相同。

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

int main(void) {
    int32_t arr[5] = {10, 20, 30, 40, 50};
    for (int32_t i = 0; i < 5; i++) {
        printf("arr[%-2d] = %2" PRId32 "  ==  *(arr+%2d) = %2" PRId32 "\n",
               i, arr[i], i, *(arr + i));
    }
    return 0;
}

🟡 中级：指针遍历 + 求和

用指针（不用 []）遍历 {3, 1, 4, 1, 5, 9, 2, 6} 并计算总和。

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

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

    int64_t sum = 0;
    int32_t *end = data + n;
    for (int32_t *p = data; p < end; p++) {
        sum += *p;
    }
    printf("sum = %ld\n", (long)sum);  /* 31 */
    return 0;
}

🔴 挑战：二维数组指针遍历

用指针（不用 []）遍历 int32_t m[2][3] = {{1,2,3},{4,5,6}}，按行打印每个元素。

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

int main(void) {
    int32_t m[2][3] = {{1, 2, 3}, {4, 5, 6}};

    for (int32_t r = 0; r < 2; r++) {
        for (int32_t c = 0; c < 3; c++) {
            /* *(*(m + r) + c) */
            printf("%2" PRId32 " ", *(*(m + r) + c));
        }
        printf("\n");
    }
    return 0;
}

故障排查 (FAQ)

Q：sizeof 为什么在函数里对参数数组不生效？

A：因为函数参数 int32_t arr[] 等同于 int32_t *arr——数组名已经退化为指针。sizeof 只能看到指针本身的大小（8 字节），不是整个数组。

Q：arr[2] 和 2[arr] 真的一样？

A：一样。因为 arr[2] → *(arr + 2) → *(2 + arr) → 2[arr]。C 标准定义了这种对称性。虽然合法，但请不要在代码里写 2[arr] 😅

Q：二维数组名 int32_t m[2][3] 是一维指针吗？

A：不是。它的类型是 int32_t (*)[3]（指向含 3 个元素的数组的指针）。要展平为一维，用 &m[0][0]。

知识扩展

指针 vs 索引：性能真相

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

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

在 x86-64 + -O2 下，GCC 和 Clang 生成完全相同的优化汇编。指针的「更快」优势是 20 年前的历史，现在纯属风格选择。

指针减法

同数组的两个指针相减，得到元素个数（不是字节数）：

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

ptrdiff_t dist = tail - head;  /* 6 个元素 */

使用 ptrdiff_t 类型（定义在 <stddef.h>），保证是足够大的带符号整数。

小结

• arr[i] 与 *(arr + i) 完全等价——编译器生成相同代码
• 数组名是地址常量，指针是可赋值变量
• sizeof 只对数组本身有效——传给函数后退化为指针
• 二维数组 = 连续行优先内存，类型是 T(*)[N] 不是 T**
• 越界指针不报错——自己负责边界

术语表

延伸阅读

• cppreference - Pointer arithmetic
• C11 标准 §6.5.2.1 — 数组下标

继续学习

• 上一章：void* 指针——万能指针与类型擦除
• 下一章：指针与函数——传递引用、返回指针

本章代码位于 src/basic/pointers_and_arrays_sample.c。

指针与函数 (Pointers and Functions)

开篇故事

想象你有一间房子，你的朋友想修改你家客厅的家具。你有两个选择：

1. 拍照给朋友——他看到客厅的样子，可以在自己的纸上做笔记，但改不了你家客厅。（值传递）
2. 给他一把钥匙——他可以直接打开你家门，移动家具。（指针传递）

指针让函数能够「穿过调用边界」修改调用者的数据。没有指针，C 函数的参数传递永远是副本——修改只在函数内部有效。有了指针，函数就能直接操作原始内存。

void swap_by_copy(int32_t a, int32_t b) {
    int32_t tmp = a; a = b; b = tmp;  /* 只修改副本 */
}

void swap_by_pointer(int32_t *a, int32_t *b) {
    int32_t tmp = *a; *a = *b; *b = tmp;  /* 修改真实数据 */
}

指针是 C 函数与外部世界沟通的桥梁。

本章适合谁

• 已掌握指针基础（&、*、NULL）
• 理解函数声明和调用
• 好奇「C 是不是只能值传递？」
• 被「函数改了数据但外部没变」困扰过的初学者

你会学到什么

1. 值传递 (pass-by-value) 的本质——函数收到副本
2. 用指针实现「传递引用」(pass-by-reference)
3. 经典陷阱：返回局部变量的地址
4. 正确模式 1：通过输出参数返回结果
5. 正确模式 2：堆分配 + 返回指针
6. 函数内修改数组内容（数组名退化为指针）
7. C 值传递 vs Python 参数传递对比

前置要求

• 已完成 指针基础 和 函数 章节
• 理解函数的参数、返回值、调用过程
• 理解栈帧 (stack frame) 的基本概念

第一个例子

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

void add_one_value(int32_t x) {
    x = x + 1;   /* 只修改副本 */
}

void add_one_pointer(int32_t *x) {
    *x = *x + 1;  /* 修改原始数据 */
}

int main(void) {
    int32_t a = 10;
    printf("before: a = %d\n", a);

    add_one_value(a);
    printf("pass-by-value: a = %d  (没变)\n", a);

    add_one_pointer(&a);
    printf("pass-by-pointer: a = %d  (变了!)\n", a);

    return 0;
}

输出：

before: a = 10
pass-by-value: a = 10  (没变)
pass-by-pointer: a = 11  (变了!)

关键理解：add_one_value(10) 收到的是 10 的副本，函数退出后副本销毁。add_one_pointer(&a) 收到的是 a 的地址，*x 操作直接修改 a 本身。

📌 回顾之前学的: C 是值传递（Pass by Value），函数参数的修改不会影响调用者。要修改调用者变量，必须传指针（& 取地址）。详见 函数。

原理解析

1. 值传递——函数收到的是副本

void foo(int32_t x) {
    x = 999;   /* 修改的是 foo 的栈帧内的副本 */
}

int32_t a = 10;
foo(a);        /* 传递 a 的值 (10) */
printf("%d\n", a);  /* 10 — 未改变 */

内存视角：

  main 的栈帧:
  a = 10  (地址 0x7ff…a0)

  foo 的栈帧 (调用时创建):
  x = 10  (地址 0x7ff…b0)  ← 副本！

  foo 返回后:
  foo 的栈帧销毁，x 的修改丢失

C 语言所有参数都是值传递——没有例外。想要修改外部变量，必须传递地址。

2. 传递引用——指针作为参数

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

int32_t x = 10, y = 20;
swap(&x, &y);
/* x = 20, y = 10 */

  调用 swap(&x, &y) 时:

  main 栈帧:        swap 栈帧:
  x = 10            a = 0x7ff…a0  (x 的地址)
  y = 20            b = 0x7ff…a8  (y 的地址)

  *a = *b  →  把 b 指向的值 (20) 写入 a 指向的位置 (x)
  *b = tmp →  把 tmp 的值写入 b 指向的位置 (y)

  结果: x 和 y 真的被交换了

┌─────── pass-by-value (值传递) ────────┐
│  swap_by_copy(x, y):                  │
│  main 栈帧       swap 栈帧 (副本)      │
│  ┌────────┐      ┌────────┐            │
│  │ x = 10 │      │ a = 10 │← x 副本    │
│  ├────────┤      ├────────┤            │
│  │ y = 20 │      │ b = 20 │← y 副本    │
│  └────────┘      └────────┘            │
│       ↓ 交换副本 → a=20, b=10          │
│  返回后: x=10, y=20  ❌ 没变            │
│                                        │
├────── pass-by-pointer (指针传递) ──────┤
│  swap_by_pointer(&x, &y):             │
│  main 栈帧       swap 栈帧 (地址)      │
│  ┌────────┐      ┌──────────┐          │
│  │ x = 10 │◄─────│ a = &x   │          │
│  ├────────┤      ├──────────┤          │
│  │ y = 20 │◄─────│ b = &y   │          │
│  └────────┘      └──────────┘          │
│       ↓ *a=20, *b=10                   │
│  x = 20, y = 10  ← 直接修改 main 变量  │
│  返回后: x=20, y=10  ✅ 交换成功        │
└────────────────────────────────────────┘

3. 经典陷阱：返回局部变量地址

int32_t *bad_func(void) {
    int32_t temp = 42;   /* 在 bad_func 的栈帧中 */
    return &temp;         /* ❌ 函数返回后栈帧销毁，地址失效 */
}

int32_t *p = bad_func();
printf("%d\n", *p);     /* ❌ 未定义行为! (野指针) */

  bad_func 栈帧:
  temp = 42   (地址 0x7ff…c0)

  函数返回后:
  [栈帧销毁] — 0x7ff…c0 变成「垃圾区」
  p 指向无效地址 → 解引用 = UB

永远不要返回局部变量的地址。局部变量存放在栈上，函数退出时自动回收。

4. 正确模式 1：输出参数

/* ✅ 通过输出参数返回结果 */
void compute_sum(int32_t a, int32_t b, int32_t *out) {
    *out = a + b;
}

int32_t result;
compute_sum(3, 4, &result);
printf("sum = %d\n", result);  /* 7 */

调用者提供存储空间，函数负责填充。返回值是 void，通过指针参数「输出」结果。这是 C 标准库的常见模式（如 scanf）。

5. 正确模式 2：堆分配返回指针

#include <stdlib.h>

int32_t *make_value(int32_t v) {
    int32_t *ptr = malloc(sizeof(int32_t));
    if (ptr == NULL) return NULL;   /* malloc 可能失败 */
    *ptr = v;
    return ptr;   /* ✅ 堆上数据函数返回后仍有效 */
}

int32_t *p = make_value(42);
printf("%d\n", *p);   /* 42 */
free(p);              /* ⚠️ 不要忘记释放 */

堆 (heap) 内存不随函数栈帧销毁，需要手动 free()。这是 strdup() 等标准库函数的原理。

6. 数组传参——退化为指针

void print_array(int32_t *data, size_t n) {
    /* data 是退化后的指针，不是数组 */
    /* sizeof(data) = 8 (指针大小), 不是数组大小 */
    for (size_t i = 0; i < n; i++) {
        printf("%d ", data[i]);
    }
}

int32_t arr[5] = {1, 2, 3, 4, 5};
print_array(arr, 5);   /* arr 退化为 int32_t* */

/* 以下三种函数声明完全等价 */
void foo(int32_t *data);
void foo(int32_t data[]);
void foo(int32_t data[5]);   /* 5 被忽略! 实际仍是 int32_t* */

数组传给函数时自动退化为指向首元素的指针。调用者必须单独传递长度。

7. C 值传递 vs Python 参数传递对比

# Python — 一切传引用
def modify(lst):
    lst.append(99)   # 修改原列表

a = [1, 2, 3]
modify(a)
print(a)  # [1, 2, 3, 99] — 变了!

// C — 基础类型值传递，需要指针
void modify(int32_t *arr, size_t n) {
    arr[n] = 99;
}

int32_t a[4] = {1, 2, 3};
modify(a, 3);  // 数组退化为指针 — 能修改

常见错误

❌ 错误 1：返回局部变量地址

char *get_string(void) {
    char msg[] = "hello";
    return msg;   /* ❌ msg 在栈上，返回后失效 */
}

/* ✅ 用 static 或堆分配 */
char *get_string(void) {
    static char msg[] = "hello";  /* static 数据在数据段，不随栈帧销毁 */
    return msg;
}

❌ 错误 2：忘记 NULL 检查输出参数

void compute(int32_t input, int32_t *out) {
    *out = input * 2;  /* ❌ 如果 out 是 NULL? 崩溃! */
}

/* ✅ 防御性检查 */
void compute(int32_t input, int32_t *out) {
    if (out == NULL) return;
    *out = input * 2;
}

❌ 错误 3：函数内用 sizeof 获取数组长度

void foo(int32_t arr[]) {
    size_t n = sizeof(arr) / sizeof(arr[0]);  /* ❌ arr 已是指针! */
}

/* ✅ 把长度作为参数传入 */
void foo(int32_t *arr, size_t n) {
    for (size_t i = 0; i < n; i++) { /* ... */ }
}

动手练习

🟢 入门：用指针翻转两个变量

编写 void flip(int32_t *a, int32_t *b)，交换 *a 和 *b 的值。

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

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

int main(void) {
    int32_t x = 3, y = 7;
    flip(&x, &y);
    printf("x = %" PRId32 ", y = %" PRId32 "\n", x, y);
    return 0;
}

🟡 中级：查找并返回指针

编写 int32_t *find(int32_t *arr, size_t n, int32_t target)，找到返回元素地址，未找到返回 NULL。

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

int32_t *find(int32_t *arr, size_t n, int32_t target) {
    int32_t *end = arr + (int32_t)n;
    for (int32_t *p = arr; p < end; p++) {
        if (*p == target) return p;
    }
    return NULL;
}

int main(void) {
    int32_t data[] = {3, 1, 4, 1, 5, 9};
    int32_t *found = find(data, 6, 5);
    if (found) {
        printf("found at index %" PRIdPTR "\n", found - data);
    }
    return 0;
}

🔴 挑战：实现 in-place 数组翻倍

编写 void double_inplace(int32_t *data, size_t n)，原地将每个元素翻倍。

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

void double_inplace(int32_t *data, size_t n) {
    int32_t *end = data + (int32_t)n;
    for (int32_t *p = data; p < end; p++) {
        *p *= 2;
    }
}

int main(void) {
    int32_t arr[] = {1, 2, 3, 4, 5};
    double_inplace(arr, 5);
    for (int32_t i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");  /* 2 4 6 8 10 */
    return 0;
}

故障排查 (FAQ)

Q：C 真的不能传引用吗？

A：C 语言标准中没有「引用」这个概念。所有参数都是值传递。想要修改外部数据，必须显式传递指针。C++ 的 & 引用语法（void foo(int &x)）在 C 中不可用。

Q：为什么传递数组时需要单独传长度？

A：因为数组传给函数时退化为 T*，编译器只知道它是指针，不知道原来数组有多少元素。sizeof 只能得到指针大小（8 字节）。

Q：函数返回 static 局部变量安全吗？

A：线程安全角度：不安全（多个线程共享同一块数据）。但在单线程程序中，static 数据存储在数据段而非栈上，函数返回后仍然有效。

知识扩展

const 输出参数——输入/输出语义

/* src 是输入（只读），dst 是输出（只写） */
void copy_string(const char *src, char *dst) {
    while (*dst++ = *src++);
}

用 const 标注输入参数，用裸指针标注输出参数，是 C API 设计的经典约定。

多维数组传参

/* 二维数组传参——必须指定列数 */
void process_matrix(int32_t matrix[][3], size_t rows) {
    /* matrix 退化为 int32_t (*)[3] */
    for (size_t r = 0; r < rows; r++) {
        for (int32_t c = 0; c < 3; c++) {
            printf("%d ", matrix[r][c]);
        }
    }
}

小结

• C 的所有参数都是值传递——函数收到的是副本
• 用指针可实现「传递引用」——修改调用者的数据
• 永远不要返回局部变量地址——栈帧销毁后变成野指针
• 正确模式：输出参数 (void foo(int *out)) 或堆分配 (malloc)
• 数组传参退化为指针，需要单独传长度

术语表

延伸阅读

• K&R《The C Programming Language》§5.3 — 指针与数组参数
• cppreference - Function parameters

继续学习

• 上一章：指针与数组
• 下一章：const 正确性

本章代码位于 src/basic/pointers_and_functions_sample.c。

const 正确性 (Const Correctness)

开篇故事

想象你在博物馆里看展品。展品后面贴着标签：「请勿触碰」。这不是建议，是规则。如果每个人都遵守这个规则，展品就能完好保存；如果有人违反，可能会造成不可逆的损坏。

const 就是 C 语言里的「请勿触碰」标签。它告诉编译器（和所有读代码的人）：这块数据不应被修改。编译器会强制这个规则——如果你试图通过 const 指针修改数据，编译直接报错。

const int32_t pi = 314;
int32_t *bad = π    /* ❌ 编译错误: 丢弃 const 限定符 */
const int32_t *good = π  /* ✅ 承认数据的 const 身份 */

const 不是可选项——它是你和编译器之间的契约。签了约，编译器帮你执行；不签约，所有安全责任都靠手动。

本章适合谁

• 已掌握指针基础（&、*、NULL）
• 看到 const int *p 和 int *const p 感到混乱的初学者
• 好奇 const 在函数参数中起什么作用
• 想写出更安全的 C 代码的程序员

你会学到什么

1. const int *p — 指向 const 的指针（不能修改所指向的值）
2. int *const p — const 指针（不能修改指针自身指向）
3. const int *const p — 双重 const（值不可改 + 指向不可改）
4. const 在函数签名中的意义：API 的契约
5. 记忆口诀：看 const 在 * 的哪一侧
6. Python 可变/不可变类型 vs C const 对比

前置要求

• 已完成 指针基础 章节
• 理解指针声明和赋值的基本语法

第一个例子

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

int main(void) {
    const int32_t pi = 314;

    /* ❌ 不能通过普通指针指向 const 数据 */
    /* int32_t *p = &pi;  // 编译错误 */

    /* ✅ 用 const 指针访问 const 数据 */
    const int32_t *p = &pi;
    printf("pi = %" PRId32 "\n", *p);

    /* *p = 999;  // ❌ 编译错误: 不能修改 const 数据 */

    int32_t other = 42;
    p = &other;   /* ✅ 可以改指向（ptr 本身不是 const） */
    printf("other = %" PRId32 "\n", *p);

    return 0;
}

核心规则：const 在 *左边，保护的是所指向的数据；const 在 *右边，保护的是指针自身。

原理解析

1. 指向 const 的指针——const T *p

const int32_t pi = 314;
const int32_t *ptr = π

  ┌──────────────────────┐
  │  const int32_t *ptr  │
  │  「我只读，不改数据」 │
  └──────────────────────┘

  pi  (const, 只读)
  ▲
  │
  ptr → 可以改指向 (ptr = &other)
  *ptr → 不能修改 (*ptr = 999 ❌)

什么可以：ptr 本身可以重新指向其他地址。 什么不可以：通过 *ptr 修改所指向的数据。

ptr = &other;   /* ✅ ptr 可以改指向 */
*ptr = 999;     /* ❌ 不能通过 ptr 修改数据 */

2. const 指针——T *const p

int32_t vals[2] = {10, 20};
int32_t *const ptr = &vals[0];

  ┌──────────────────────┐
  │  int32_t *const ptr  │
  │  「我不能换目标，    │
  │    但可以改数据」     │
  └──────────────────────┘

  ptr → 不能改指向 (ptr = &vals[1] ❌)
  *ptr → 可以修改 (*ptr = 99 ✅)

什么可以：通过 *ptr 修改所指向的数据。 什么不可以：ptr 本身不能重新指向。

*ptr = 99;           /* ✅ 可以修改值 */
ptr = &vals[1];      /* ❌ const 指针不能改指向 */

3. 双重 const——const T *const p

const int32_t secret = 777;
const int32_t *const ptr = &secret;

  ┌──────────────────────────┐
  │  const int32_t *const ptr│
  │  「我只读，且不能换目标」 │
  └──────────────────────────┘

  ptr  → 不能改指向
  *ptr → 不能修改值
  完全只读 = 最高级别保护

4. 记忆口诀——看 const 的位置

最可靠的方法：从右往左读指针声明。

速记法：const 在 *左边保护数据，在 *右边保护指针。

5. const 在函数签名中的力量

const 是函数的「契约」——告诉调用者函数会/不会修改什么：

/* 契约: 我不会修改你传入的字符串 */
size_t my_strlen(const char *s) {
    size_t len = 0;
    while (s[len] != '\0') len++;
    return len;
}

/* 契约: dest 可写, src 只读 */
void copy_string(char *dest, const char *src) {
    while (*dest++ = *src++);
}

/* 调用时 */
const char msg[] = "hello";
size_t len = my_strlen(msg);  /* ✅ my_strlen 承诺不修改 msg */

char msg2[] = "hello";
size_t len2 = my_strlen(msg2);  /* ✅ 即使是非 const 也能传给 const 参数 */

6. Python 可变/不可变 vs C const 对比

# Python — 运行时保护
x = (1, 2, 3)     # tuple 不可变
x[0] = 99         # TypeError (运行时)

// C — 编译时保护
const int32_t arr[] = {1, 2, 3};
const int32_t *p = arr;
*p = 99;          /* ❌ 编译错误 — 根本过不了编译 */

C 的 const 更严格——在代码运行前就阻止了错误。

常见错误

❌ 错误 1：隐式丢弃 const

const int32_t pi = 314;
int32_t *p = π   /* ❌ 编译错误: discards 'const' qualifier */
*p = 999;           /* 试图去除 const 保护修改数据 */

/* ✅ 修正: 使用 const 指针 */
const int32_t *p = π
/* *p = 999; 仍然编译错误 — 这就是 const 的意义 */

❌ 错误 2：双重 const 误用

int32_t val = 10;
const int32_t *const p = &val;

*p = 20;    /* ❌ 不能通过双重 const 改值 */
p = &other; /* ❌ 不能改指向 */

/* 如果只需要保护数据，用单层 const */
const int32_t *p = &val;  /* ✅ 值不可改，指向可改 */

❌ 错误 3：const 指针指向非 const 数据

/* 这本身合法，但要注意语义 */
int32_t val = 10;
const int32_t *p = &val;
/* *p = 20; ❌ 但 val 本身不是 const! */
val = 20;   /* ✅ val 可以通过自身名字修改 */

通过 const 指针读数据是一种「承诺不通过该指针修改」，不代表数据本身不可变。

动手练习

🟢 入门：识别 const 类型

判断以下声明中哪些可以改数据，哪些可以改指向：

const int32_t *a;    // ?
int32_t *const b;    // ?
const int32_t *const c;  // ?

a: 数据❌, 指向✅   (指向 const 的指针)
b: 数据✅, 指向❌   (const 指针)
c: 数据❌, 指向❌   (双重 const)

🟡 中级：安全读取函数

编写 int read_value(const int32_t *ptr, int32_t *out)，当 ptr 为 NULL 时返回 0，否则通过 out 返回 *ptr。

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

int read_value(const int32_t *ptr, int32_t *out)
{
    if (ptr == NULL || out == NULL) return 0;
    *out = *ptr;
    return 1;
}

int main(void) {
    const int32_t secret = 42;
    int32_t result = 0;
    if (read_value(&secret, &result)) {
        printf("value = %d\n", result);
    }
    return 0;
}

🔴 挑战：const 正确的字符串复制

编写 void safe_copy(char *dest, size_t dest_size, const char *src, size_t count)，确保 dest 可写、src 只读，复制不超过 count 字节且始终 null 终止。

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

void safe_copy(char *dest, size_t dest_size, const char *src, size_t count)
{
    size_t max = dest_size - 1;
    if (count < max) max = count;
    memcpy(dest, src, max);
    dest[max] = '\0';
}

int main(void) {
    const char msg[] = "hello world";
    char buf[6];
    safe_copy(buf, sizeof(buf), msg, 100);
    printf("'%s' (len %zu)\n", buf, strlen(buf));
    return 0;
}
/* 输出: 'hello' (len 5) — 安全截断 */

故障排查 (FAQ)

Q：const int *p 和 int const *p 有什么区别？

A：没有区别。它们在 C 标准中等价。但 const int *p 更常见，因为「const 修饰类型」的直觉更清晰。

Q：const 和 #define 宏常量有什么不同？

A：#define PI 3.14 是文本替换，没有类型，没有地址。const double pi = 3.14; 是真正的变量，有类型、有地址、受编译器检查。优先使用 const。

Q：函数参数用 const 会影响性能吗？

A：不会。const 是编译期语义，不生成额外代码。它只影响编译检查，不影响运行时行为。现代编译器甚至可能利用 const 做更好的优化（因为知道数据不会变）。

知识扩展

const 的 volatile 搭档

const volatile int32_t *reg = (const volatile int32_t *)0x40000000;

const volatile 一起使用——告诉编译器「数据不可通过本程序修改，但可能被硬件改变，不要优化掉每次读取」。常用于嵌入式系统的寄存器访问。

const 与字符串字面量

const char *s = "hello";
/* s[0] = 'H';  ← ❌ 字符串字面量存储在 .rodata 段（只读） */

char s2[] = "hello";
/* s2[0] = 'H'; ← ✅ char[] 在栈上，可修改 */

小结

• const T *p — 指向 const：不能通过 p 修改数据，p 可以改指向
• T *const p — const 指针：p 不能改指向，可以通过 *p 修改数据
• const T *const p — 双重 const：值和指向都不可改
• 速记：const 在 * 左边保护数据，在 * 右边保护指针
• const 是编译期契约——在运行前就阻止错误