C语言学习笔记 on Hobin's Blog

1.1 C语言简介

Mon, 13 Apr 2026 15:30:00 +0800

C语言简介

概念说明

C 语言是一门通用的编译型程序设计语言，强调直接、精简和高效。它既可以写接近硬件的底层程序，也可以写结构清晰的通用工具，因此一直被操作系统、编译器、数据库、嵌入式和高性能基础组件广泛使用。

学 C 语言最有价值的地方，不只是掌握一套语法。更重要的是通过它理解变量为什么会占用内存、数组为什么连续存放、函数调用为什么会形成栈帧、指针为什么能修改外部数据。

C 语言也有明显边界。它不会自动帮你管理内存，不会自动检查数组越界，也不会用统一异常机制替你处理错误。正因为这些“默认不帮忙”，C 才特别适合训练程序员的基本功。

可以先把 C 语言的典型特点记成下面几条：

语法相对精简，核心概念少，但每个概念都很重要。
更接近机器执行模型，很多行为和内存布局、字节序、调用约定有关。
可移植性强，但某些细节仍与编译器、平台和标准版本有关。
运行时抽象较少，性能可控，但需要程序员自己负责资源管理。

语法/规则

C 源文件通常使用 .c 作为扩展名，头文件通常使用 .h。
程序入口通常是 main 函数，常见写法是 int main(void) 或 int main(int argc, char *argv[])。
C 程序需要先编译，再链接，最后才能运行可执行文件。
C 标准常见版本有 C89、C99、C11 和 C17，学习资料提到的行为要注意对应标准。
C 和 C++ 语法有交集，但它们不是同一门语言，很多写法不能直接混用。
学习 C 语言时，效率和安全性常常需要靠程序员自己平衡，编译器不会替你兜底所有问题。

示例

1
2
3
4
5
6


#include <stdio.h>

int main(void) {
 printf("Hello, C!\n");
 return 0;
}

输出结果：

1

Hello, C!

这个例子虽然很短，但已经包含了后面会不断出现的几个核心元素：头文件、main 函数、函数调用、字符串字面量和返回值。

常见错误

把 C 和 C++ 当成同一门语言，直接混用 cout、引用、类和 new 这类 C++ 语法。
只记住表面语法，不去理解地址、内存、生命周期和数据布局这些底层概念。
以为“程序能跑”就说明写法可靠，忽略了 C 里还有越界、未初始化、悬空指针这类高风险问题。
上来就追求复杂项目，反而跳过了最重要的基础：编译、调试、数组、指针和函数调用过程。

1.2 环境设置

Mon, 13 Apr 2026 15:30:00 +0800

环境设置

概念说明

写 C 程序最基础的开发环境由三部分组成：编辑器、编译器和终端。编辑器负责写代码，编译器负责把源文件变成目标文件和可执行文件，终端负责执行编译命令、运行程序和查看错误信息。

无论你使用的是 Windows、Linux 还是 macOS，真正的主线都一样： 写代码 -> 编译 -> 运行 -> 看输出或看报错 -> 修改后再次编译。

初学阶段不要一开始就在很多 IDE 之间反复切换。先固定一套最小环境，能稳定完成“新建文件、编译、运行、看警告”这几件事，比工具本身的高级功能更重要。

语法/规则

Windows 上常见的是 MinGW-w64、MSYS2 或 Visual Studio 自带工具链；Linux 和 macOS 上常见的是 gcc 或 clang。
安装完成后，先在终端确认编译器是否可用，例如执行 gcc --version 或 clang --version。
建议初学阶段使用带警告和调试信息的编译参数，例如 -std=c11 -Wall -Wextra -g。
编译源文件的基础命令是 gcc hello.c -o hello，其中 -o 用来指定输出文件名。
Windows 上通常运行 hello.exe 或 ./hello.exe，类 Unix 系统上通常运行 ./hello。
如果代码修改后运行结果没变化，首先检查自己是不是忘了重新编译。
输入法和标点也会影响代码，中文引号、中文分号、中文括号都会导致编译失败。

示例

1
2
3
4
5
6


#include <stdio.h>

int main(void) {
 printf("Hello, C environment!\n");
 return 0;
}

1
2


gcc hello.c -std=c11 -Wall -Wextra -g -o hello
./hello

输出结果：

1

Hello, C environment!

这组命令除了生成可执行文件，还打开了常用警告和调试信息。后面你开始排查错误时，这些选项会非常有帮助。

常见错误

编译器已经安装，但其 bin 目录没有加入环境变量，导致终端找不到 gcc 或 clang。
代码改完以后直接运行旧的可执行文件，没有重新编译，误以为程序“没有生效”。
在 Windows 和 Linux/macOS 上混用运行命令，例如把 hello.exe 和 ./hello 的用法写反。
代码里混入中文标点、全角空格或错误编码，导致编译器报出看起来很奇怪的语法错误。
一上来就依赖 IDE 的按钮，而不理解背后做了什么，后面遇到构建失败时就很难定位问题。

1.3 程序结构与基础语法

Mon, 13 Apr 2026 15:30:00 +0800

程序结构与基础语法

概念说明

一个最小的 C 程序通常包含头文件引用、函数定义、变量声明、表达式和语句。编译器依靠关键字、分号、花括号和标识符来理解程序结构，所以这些最基础的书写规则一开始就要养成习惯。

C 代码里的空白符主要服务于可读性。多数情况下，空格、缩进和换行不会改变程序含义，但它们会直接影响你以后能不能快速看懂自己的代码。

此外，初学阶段经常被混淆的还有几个概念：

标识符：程序员自己起的名字，例如变量名、函数名。
关键字：语言保留字，例如 int、return、if。
表达式：会产生值的代码片段，例如 a + b。
语句：完成一个完整动作的最小执行单位，例如 sum = a + b;。

语法/规则

#include 用来引入头文件，让编译器知道函数声明、类型声明和宏定义。
main 是程序入口，普通可执行语句必须写在函数体内部。
一条完整语句通常以分号 ; 结束，代码块使用 {} 包裹。
标识符只能由字母、数字和下划线组成，且不能以数字开头。
关键字不能作为标识符使用，例如不能把变量命名为 int、return 或 while。
单行注释使用 //，多行注释使用 /* ... */，多行注释不能嵌套。
C 对大小写敏感，sum、Sum 和 SUM 是三个不同名字。
相邻字符串字面量会自动拼接，但普通表达式不会自动跨行拼接。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#include <stdio.h>

int main(void) {
 int first = 3;
 int second = 5;
 int sum = first + second;

 // 输出本次计算结果
 printf("sum = %d\n", sum);
 return 0;
}

输出结果：

1

sum = 8

这个例子里，first + second 是表达式，int sum = first + second; 和 printf(...) 都是语句。用这种方式去区分“值”和“动作”，后面读复杂代码会更轻松。

常见错误

漏掉分号，结果编译器往往在下一行才报错，看起来像“报错位置不对”。
把可执行语句写在函数外面，忘了 C 里的普通语句必须放在函数体中。
使用关键字作为变量名，或者把大小写不同但含义接近的名字混着用。
把 /* ... */ 当成可嵌套注释，结果在较长注释中提前结束注释块。
过度省略空格和换行，导致程序虽然能编译，但阅读和排错非常困难。

1.4 进制、编码与内存基础

Tue, 14 Apr 2026 00:00:00 +0800

进制、编码与内存基础

概念说明

计算机底层并不直接认识“数字 12”“字母 A”或“字符串 hello”。对它来说，数据最终都是一串二进制位，也就是由 0 和 1 组成的比特序列。

为了方便阅读，程序员经常用不同进制去表示同一份数据：

二进制适合直接观察位模式。
八进制和十六进制适合压缩表示长二进制串。
十进制更适合人类日常理解数量大小。

文字要进入计算机，还需要一套“字符和编号如何对应”的规则，这就是字符编码。学 C 语言时最常遇到的不是“C 只支持 ASCII”，而是：字符如何存到内存里、一个字符到底占几个字节、字符串为什么要以 '\0' 结尾。

同时还要建立一个基本概念：内存是按字节编址的。一个字节通常等于 8 位，而变量、数组和结构体最终都要落到一段连续或不连续的内存区域里。后面学 sizeof、数组、指针和文件读写时，这个基础会不断用到。

语法/规则

1 Byte = 8 Bit，位是最小的二进制单位，字节是更常见的存储单位。
十进制字面量直接写，例如 26；八进制常以前导 0 开头，例如 032；十六进制以 0x 或 0X 开头，例如 0x1A。
标准 C 的整数写法里，0 开头不表示“普通十进制”，而通常表示八进制，这一点非常容易写错。
字符编码描述的是“字符与编号的关系”，常见有 ASCII、GBK、Unicode、UTF-8 等。
字符串在 C 里本质上是以 \0 结尾的字符序列，因此字符串长度和实际占用的数组空间不完全是一回事。
内存里的同一串比特，按不同类型解释时可能得到完全不同的含义，这也是类型系统和强制类型转换重要的原因。
十六进制在调试中非常常见，因为它和二进制之间转换方便，也很适合观察地址、掩码和字节内容。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>

int main(void) {
 int value = 26;
 char letter = 'A';

 printf("decimal = %d\n", value);
 printf("octal = %o\n", value);
 printf("hex = %X\n", value);
 printf("letter = %c\n", letter);
 printf("code = %d\n", letter);
 return 0;
}

输出结果：

1
2
3
4
5


decimal = 26
octal = 32
hex = 1A
letter = A
code = 65

这个例子说明了两件事：同一个整数可以用不同进制显示；字符 'A' 在底层也可以按它的编码值 65 来观察。

常见错误

把 012 当成十进制 12，实际上它通常会被解释为八进制字面量。
以为 C 语言“固定只用 ASCII”，忽略了源文件编码、终端编码和运行环境编码都会影响字符显示。
把字符常量 'A' 和字符串字面量 "A" 当成同一种东西来用。
忘记字符串末尾还需要一个 \0，导致数组空间预留不够。
只会背 KB、MB 这些单位，却不知道数组长度、sizeof 和文件大小最终都要落回字节这个尺度上理解。

1.5 编译、链接与诊断基础

Tue, 14 Apr 2026 00:00:00 +0800

编译、链接与诊断基础

概念说明

我们写出来的 .c 文件并不能被 CPU 直接执行。源代码需要先经过预处理、编译、汇编和链接，最后才会生成可执行文件。

可以先把这个流程理解成两层：

编译：把单个源文件翻译成机器可理解的目标代码。
链接：把多个目标文件和库拼装起来，补齐函数和变量之间的引用关系，生成最终程序。

当程序报错时，也要先分清自己卡在哪个阶段：

编译期错误：语法不对、类型不匹配、缺少声明。
链接期错误：函数声明了但没有定义，或者同名定义重复。
运行期错误：程序已经生成，但执行时逻辑出错、崩溃或结果异常。

初学阶段如果能先把这三类问题分开，你排错的效率会明显提高。

语法/规则

一个 .c 源文件通常会先经过预处理，再被编译成目标文件，最后参与链接。
.h 头文件更适合放声明，.c 源文件更适合放定义和实现。
多文件程序在链接时必须把真正实现所在的源文件一起编进去，否则会出现“未定义引用”之类的链接错误。
建议初学阶段使用 -Wall -Wextra 打开常用警告，把警告当成需要认真处理的信号。
-g 选项会把调试信息写入可执行文件，方便后面使用调试器。
编译器报出的“第一条错误”通常最关键，后续很多报错可能只是连锁反应。
项目里一旦有多个源文件，就应该开始养成“头文件写声明，源文件写实现”的基本工程习惯。

示例

1
2
3
4
5
6
7


/* math_tools.h */
#ifndef MATH_TOOLS_H
#define MATH_TOOLS_H

int add(int a, int b);

#endif

1
2
3
4
5
6


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

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

1
2
3
4
5
6
7
8


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

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

1
2


gcc main.c math_tools.c -std=c11 -Wall -Wextra -g -o app
./app

输出结果：

1

sum = 7

这个例子里，main.c 通过头文件知道 add 的声明，真正的实现则来自 math_tools.c。如果编译命令里漏掉 math_tools.c，通常就会在链接阶段报错。

常见错误

只写了函数声明，却没有真正提供实现，导致链接失败。
把函数实现直接写进头文件，又被多个源文件包含，造成重复定义。
看到大量错误信息就慌张修改，结果没有先处理最早出现的那条关键报错。
把编译错误、链接错误和运行时错误混成一类，导致排错方向完全错位。
明明已经开启了警告，却把警告全部忽略，错过了很多早期暴露问题的机会。

2.1 数据类型

Mon, 13 Apr 2026 15:30:00 +0800

数据类型

概念说明

数据类型决定了变量占用多少内存、能表示什么范围，以及编译器应该怎样解释那一段二进制数据。同样的 4 个字节，如果按 int 看是整数，按 float 看则可能表示浮点数，类型不同，解释方式也完全不同。

C 的基础类型可以先按下面几组理解：

整型：char、short、int、long、long long
浮点型：float、double、long double
布尔型：_Bool，常配合 <stdbool.h> 中的 bool
特殊类型：void

学类型时最重要的一点是区分“语言保证”和“平台常见现象”。例如 char 一定是 1 字节，但 int、long、long double 的大小会因平台和编译器而不同。

语法/规则

整型可以搭配 signed 或 unsigned 修饰，表示有符号或无符号整数。
char 既可以表示字符，也是一种很小的整型，常用来存储单个字节。
float、double、long double 用来表示小数，精度和范围通常逐步增加。
void 表示“没有具体值”，常见于无返回值函数、无参数函数和通用指针 void *。
_Bool 是 C99 引入的布尔类型；如果想写成 bool，通常需要包含 <stdbool.h>。
sizeof(type) 或 sizeof value 可以查看类型或对象占用的字节数，结果类型通常是 size_t。
输出不同类型时，要尽量使用匹配的格式控制符，例如 %d、%u、%lld、%f、%c、%zu。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


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

int main(void) {
 int count = 42;
 double price = 19.8;
 char grade = 'A';
 bool passed = true;

 printf("count = %d\n", count);
 printf("price = %.1f\n", price);
 printf("grade = %c\n", grade);
 printf("passed = %d\n", passed);
 printf("sizeof(int) = %zu\n", sizeof(int));
 printf("sizeof(double) = %zu\n", sizeof(double));
 return 0;
}

输出结果：

1
2
3
4
5
6


count = 42
price = 19.8
grade = A
passed = 1
sizeof(int) = 4
sizeof(double) = 8

sizeof(int) 和 sizeof(double) 的结果在常见平台上经常分别是 4 和 8，但学习时仍然要记住：某些类型大小并不是所有平台都完全固定。

常见错误

把不同平台上的类型大小当成绝对常识，例如默认认为 long 一定是 8 字节。
用错误的格式控制符输出数据，例如用 %d 输出 double 或用 %f 输出整数。
不区分 signed 和 unsigned，在比较和运算时得到意外结果。
把 char 只当字符看，忽略它本质上也是一个小整数类型。
看到 sizeof 的结果就直接硬编码进程序，而不是让代码根据类型自动计算字节数。

2.2 变量

Mon, 13 Apr 2026 15:30:00 +0800

变量

概念说明

变量是程序运行过程中可读可写的一块存储区域。在 C 语言里，变量一旦绑定了类型，编译器就会按这个类型分配空间，并按对应规则解释其中的二进制数据。

学变量时最重要的几个区分是：

定义 和 声明 不是同一回事。
局部变量 和 全局变量 的默认初始化规则不同。
作用域 解决的是“哪里能看到这个名字”，生命周期 解决的是“这块对象活多久”。

变量命名虽然是语法上最自由的一部分，但它对代码可读性的影响非常大。一个叫 user_count 的变量，和一个叫 a1 的变量，后期维护成本会完全不同。

语法/规则

变量定义的一般形式是 类型变量名; 或 类型变量名 = 初始值;。
同类型变量可以并列定义，例如 int x = 1, y = 2;，但复杂场景下分开写通常更清晰。
extern 常用于只声明、不在当前位置分配存储空间，真正的定义通常在别处。
全局变量和静态变量如果没有显式初始化，通常会被初始化为 0；局部非静态变量不会自动初始化。
建议变量在第一次使用前就完成初始化，减少未初始化读的问题。
变量名应尽量表达含义，例如 total_score、file_count，而不是泛泛的 a、tmp。
当变量只在很小的范围内有意义时，尽量把它定义在靠近使用位置的地方。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>

int total = 0;

int main(void) {
 int age = 18;
 int level = 1;

 total = age + level;

 printf("age = %d\n", age);
 printf("level = %d\n", level);
 printf("total = %d\n", total);
 return 0;
}

输出结果：

1
2
3


age = 18
level = 1
total = 19

这个例子里，total 是文件作用域变量，age 和 level 是 main 函数内部的局部变量。它们的可见范围和生命周期都不一样。

常见错误

使用局部变量前没有初始化，却直接参与计算或输出。
以为 extern int count; 已经创建了变量，实际上它通常只是声明。
同一个全局变量在多个源文件里重复定义，最终引发链接错误。
变量命名过于随意，到处复用 a、b1、tmp2 这类无语义名字，后面阅读和调试会很痛苦。
把变量定义得过早或过宽，导致本来只在小范围使用的数据泄漏到更大作用域里。

2.3 常量

Mon, 13 Apr 2026 15:30:00 +0800

常量

概念说明

常量表示在程序中不希望被修改的固定值。在 C 语言里，常量既可以是直接写在代码中的字面量，也可以通过 const、enum 或 #define 给它们起一个有语义的名字。

常量最重要的价值不是“语法更高级”，而是让代码更清楚。例如把 3.1415926 写成 PI，把 86400 写成 SECONDS_PER_DAY，代码含义会直观很多。

另外，很多初学者只把常量理解成数字。其实字符常量、字符串字面量、十六进制字面量、转义字符和浮点字面量，都是常量世界的一部分。

语法/规则

数字、字符、字符串本身都是字面量，例如 100、'A'、"hello"。
十进制、八进制和十六进制整数字面量都很常见，例如 26、032、0x1A。
字符和字符串里可以使用转义字符，例如 \n、\t、\\、\"、\0。
const 用来声明只读对象，例如 const int max_users = 100;。
#define 会在预处理阶段进行文本替换，例如 #define PI 3.14159。
宏常量没有类型，const 对象有类型；在调试、类型检查和作用域表现上两者并不相同。
相邻的字符串字面量会自动拼接，这在书写较长提示文本时很实用。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>

#define PI 3.14159
#define SECONDS_PER_DAY 86400

int main(void) {
 const int radius = 2;
 double area = PI * radius * radius;

 printf("radius = %d\n", radius);
 printf("area = %.2f\n", area);
 printf("seconds = %d\n", SECONDS_PER_DAY);
 printf("newline demo -> line1\nline2\n");
 return 0;
}

输出结果：

1
2
3
4
5


radius = 2
area = 12.57
seconds = 86400
newline demo -> line1
line2

语法补充

长字符串可以通过相邻字面量自动拼接，写法如下：

1
2
3


const char *message =
 "This is a long string. "
 "It will be concatenated by the compiler.";

这种写法比手动在每一行里加入很多转义符更易读。

常见错误

以为 const 对象和宏常量完全一样，忽略了它们在类型检查和调试上的区别。
直接修改 const 变量，或者通过不安全方式强行改写只读数据。
忽略前导 0 的含义，把八进制字面量误写成了十进制。
把大量业务含义不明的数字直接写进代码里，形成难以维护的魔法数字。
忘记转义字符会真正影响字符串内容，例如 \n 会换行、\0 会终止字符串。

2.4 存储类

Mon, 13 Apr 2026 15:30:00 +0800

存储类

概念说明

存储类描述的是变量或函数在程序中的存储位置、生命周期和可见范围。它解决的不是“变量是什么类型”，而是“这个名字能活多久、在哪些地方能被看到、是不是能跨文件访问”。

学这一节时，最容易混淆的是三件事：

作用域：名字在哪些代码位置可见。
存储期：对象从什么时候创建，到什么时候销毁。
链接属性：同一个名字能否在多个源文件之间共享。

static 和 extern 容易让人一开始就绕晕，原因也在这里。 static 更强调存储期或内部链接，extern 更强调“定义在别处，我这里只引用它”。

语法/规则

普通局部变量默认具有自动存储期，函数调用结束后通常就失效。
static 局部变量只初始化一次，函数多次调用时会保留上一次的值。
static 用在文件作用域变量或函数前，通常表示仅在当前源文件内部可见。
extern 用于声明一个在其他文件或其他位置定义的全局对象。
register 表示建议编译器优先使用寄存器保存变量，但现代编译器通常会自己决定优化方式。
存储类不会改变变量的基本数据类型，但会影响初始化时机、生命周期和可见范围。
同一个名字是否能跨文件共享，不只看作用域，还要看链接属性。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <stdio.h>

void visit(void) {
 static int count = 0;
 count++;
 printf("count = %d\n", count);
}

int main(void) {
 visit();
 visit();
 visit();
 return 0;
}

输出结果：

1
2
3


count = 1
count = 2
count = 3

这里的 count 虽然写在函数内部，但它不是每次进入 visit 时都重新创建。这正是 static 局部变量和普通局部变量最关键的区别。

常见错误

以为 static 局部变量会在每次进入函数时重新初始化。
只写了 extern 声明，却没有真正提供对应的定义。
把生命周期、作用域和链接属性混成同一件事，导致全局变量设计混乱。
把本该只在当前文件使用的名字暴露成外部可见，增加不必要的耦合。
误以为 register 一定会带来性能提升，忽略现代编译器本来就会自动优化。

2.5 运算符

Mon, 13 Apr 2026 15:30:00 +0800

运算符

概念说明

运算符用于对一个或多个操作数执行计算、比较、逻辑判断或赋值。 C 语言里的运算符很多，但初学阶段最重要的不是死记所有符号，而是理解表达式求值的规则和副作用。

可以先把常见运算符分成几类：

算术运算符：+、-、*、/、%
关系运算符：>、<、>=、<=、==、!=
逻辑运算符：&&、||、!
赋值运算符：=、+=、-= 等
条件运算符：条件 ? 值1 : 值2
自增自减：++、--

复杂表达式的问题通常不在“编译不过”，而在“人读不懂”。一旦一个表达式同时混入赋值、自增、函数调用和比较，它就很容易变成未来排错的负担。

语法/规则

整数除法会截断小数部分，例如 5 / 2 的结果是 2。
% 取模运算只适用于整数类型。
关系运算的结果在 C 中是整数语义，条件里 0 表示假，非 0 表示真。
&& 和 || 具有短路特性，左侧已经能确定结果时，右侧表达式可能不会执行。
条件运算符适合较短的二选一逻辑，超过这个复杂度时通常 if 更清楚。
++i 和 i++ 都会让 i 增加 1，但表达式本身的取值时机不同。
运算符有优先级和结合性，但真实开发中与其死背，不如在关键位置主动加括号明确意图。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <stdio.h>

int main(void) {
 int chinese = 82;
 int math = 91;
 int average = (chinese + math) / 2;
 int passed = average >= 85 && average <= 100;
 int next_level = passed ? 2 : 1;

 printf("average = %d\n", average);
 printf("passed = %d\n", passed);
 printf("next_level = %d\n", next_level);
 return 0;
}

输出结果：

1
2
3


average = 86
passed = 1
next_level = 2

规则补充

当你不确定优先级时，直接加括号通常是更稳妥的做法，例如：

1

int result = (a + b) * c;

这种写法往往比完全依赖优先级表更容易读，也更不容易引入误解。

常见错误

把 = 写成 ==，或者把 == 写成 =，导致判断逻辑完全变掉。
忽略整数除法会截断小数，例如 5 / 2 的结果是 2 而不是 2.5。
在同一个表达式里混入太多 ++、赋值和函数调用，导致求值顺序难以判断。
把位运算符 &、| 和逻辑运算符 &&、|| 混着用。
过度依赖“我记得这个优先级”，却没有在关键表达式上补括号澄清意图。

2.6 强制类型转换

Mon, 13 Apr 2026 15:30:00 +0800

强制类型转换

概念说明

类型转换表示把一个值按另一种类型去解释，或生成另一种类型的结果。 C 会在很多场景下自动进行隐式转换，但当你需要明确控制计算结果或接口类型时，就会用到显式转换，也就是强制类型转换。

学这一节时，最关键的是理解：转换能影响“接下来如何计算”，但不能凭空恢复已经丢失的信息。

例如整数除法 5 / 2 的结果已经是整数 2 了，这时候再把它转成 double，得到的也只是 2.0。真正应该做的是让浮点计算在除法发生之前就介入。

语法/规则

强制类型转换的基本形式是 (目标类型)表达式。
如果想避免整数除法截断，应该在除法发生前就参与浮点计算。
隐式转换会遵循整型提升和常用算术转换等规则，但结果不一定总符合你的直觉。
从更大范围的类型转换到更小范围的类型，可能发生截断或精度丢失。
指针转换要格外谨慎，错误的目标类型可能让后续解引用产生严重问题。
不要为了“让警告消失”而随手加转换，先判断警告是否揭示了真实的设计问题。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <stdio.h>

int main(void) {
 int total = 5;
 int count = 2;
 double average = (double)total / count;

 printf("average = %.2f\n", average);
 return 0;
}

输出结果：

1

average = 2.50

在这个例子里，(double)total 让后续的除法进入了浮点运算路径，所以结果不再被整数截断。

常见错误

先做完整数除法再去转换，例如 (double)(5 / 2)，结果仍然是 2.00。
误以为强制转换能修复所有精度或溢出问题，实际上很多信息在更早阶段就已经丢失了。
为了消除编译警告随手加类型转换，结果把真正的类型设计问题掩盖掉。
把不同类型指针强转后直接解引用，却没有确认目标对象的真实类型和对齐要求。
从浮点数强转到整数时，忽略小数部分会被截断而不是四舍五入。

3.1 判断语句

Mon, 13 Apr 2026 15:30:00 +0800

判断语句

概念说明

判断语句用于根据条件不同执行不同分支。在 C 语言里，最常见的条件分支写法是 if 系列和 switch。

这两种写法解决的是不同问题：

if 更适合范围判断、组合条件和布尔表达式。
switch 更适合“某个表达式等于哪一个离散常量值”的场景。

分支写得清不清楚，往往比“能不能跑”更重要。同样的逻辑，如果选择了更贴切的分支形式，后续维护会轻松很多。

语法/规则

if 条件表达式的结果为 0 时表示假，非 0 时表示真。
else if 会按书写顺序依次判断，命中后后续分支不会再执行。
switch 适合判断整数、字符或枚举这类离散值，不适合范围判断。
case 后面必须是编译期可确定的常量表达式。
switch 中如果不写 break，程序会继续向下执行后续 case，这叫贯穿或落空。
default 不是必须写，但在分支不完整时通常建议保留。
对于复杂条件，与其追求一行写完，不如用括号和局部变量把意图写清楚。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <stdio.h>

int main(void) {
 int score = 86;
 int day = 3;

 if (score >= 90) {
 printf("grade = A\n");
 } else if (score >= 80) {
 printf("grade = B\n");
 } else {
 printf("grade = C\n");
 }

 switch (day) {
 case 1:
 printf("day = Monday\n");
 break;
 case 2:
 printf("day = Tuesday\n");
 break;
 case 3:
 printf("day = Wednesday\n");
 break;
 default:
 printf("day = Unknown\n");
 break;
 }

 return 0;
}

输出结果：

1
2


grade = B
day = Wednesday

常见错误

在判断里把 == 错写成 =，结果条件表达式被赋值而不是比较。
switch 分支漏写 break，导致程序继续落入后续分支。
用 switch 去写区间判断，结果代码越来越绕，还不如直接使用 if。
花括号省略过多，后续改动时很容易出现“实际只控制了一条语句”的问题。
条件表达式写得过于复杂，自己一个月后都看不懂原来想表达什么。

3.2 循环

Mon, 13 Apr 2026 15:30:00 +0800

循环

概念说明

循环用于重复执行一段代码，直到满足退出条件。 C 语言提供了 while、do while 和 for 三种常见循环结构，它们适合的场景略有不同。

大多数循环错误并不是语法写错，而是边界、更新时机和退出条件没有想清楚。所以写循环时，最好先明确三件事：从哪里开始、什么时候结束、每轮怎么推进。

可以先这样理解：

while：先判断，再决定要不要执行。
do while：先执行一次，再判断是否继续。
for：把初始化、条件和更新写在同一处，更适合计数型循环。

语法/规则

while 在进入循环体前先检查条件，因此可能一次也不执行。
do while 至少会执行一次循环体，因为判断发生在末尾。
for (初始化; 条件; 更新) 适合计数型或遍历型逻辑。
break 用于提前结束整个循环，continue 用于跳过本轮剩余语句进入下一轮。
嵌套循环时，要格外注意内外层变量名、边界和退出条件。
循环变量最好只由一个明确位置更新，避免“多处修改”带来的混乱。
写完循环后，最好手动检查首轮、末轮和空输入这三类边界情况。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>

int main(void) {
 int sum = 0;

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

 printf("sum = %d\n", sum);
 return 0;
}

输出结果：

1

sum = 25

这个例子里，continue 跳过了所有偶数，只把 1 到 10 之间的奇数累加起来。

常见错误

循环变量没有更新，导致死循环。
边界条件写错，例如 i < n 和 i <= n 混淆，产生 off-by-one 错误。
for 或 while 后面误写一个分号，导致循环体变成空语句。
在多个位置同时修改循环变量，最后连自己都说不清一轮到底怎么推进。
只测试“正常输入”，没有验证空数组、零次循环和最后一轮边界。

3.3 函数

Mon, 13 Apr 2026 15:30:00 +0800

函数

概念说明

函数用于封装一段可以重复调用的逻辑。把程序拆成多个职责明确的小函数，能让代码更容易阅读、测试和维护。

从执行模型上看，函数调用并不是“跳过去执行一下”这么简单。每次调用都会形成一层新的调用上下文，用来保存参数、局部变量和返回位置，这也是后面理解递归和调试调用栈的基础。

C 语言里函数通常包含返回类型、函数名、参数列表和函数体。如果函数定义写在调用之后，通常需要先写函数声明，也叫函数原型。

语法/规则

函数定义的基本形式是 返回类型函数名(参数列表) { ... }。
函数声明只写签名，不写函数体，例如 int max(int a, int b);。
函数参数默认采用值传递，函数内部修改形参不会直接改掉调用方实参。
返回值类型应和 return 表达式保持一致，避免隐式转换掩盖问题。
函数原型最关键的信息是返回类型和参数类型，它让编译器知道该如何检查调用是否合法。
同一职责的代码尽量收敛到一个函数里，避免把一段逻辑复制粘贴到多个位置。
对外复用的函数声明更适合放在头文件中，具体实现放在 .c 文件中。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>

int sum_range(int begin, int end);

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

int sum_range(int begin, int end) {
 int sum = 0;

 for (int i = begin; i <= end; i++) {
 sum += i;
 }

 return sum;
}

输出结果：

1

result = 15

这个例子同时展示了三件事：函数声明、函数调用，以及把实现写在 main 之后时为什么还需要原型。

常见错误

函数在调用前没有声明，结果依赖旧式规则或直接触发编译错误。
返回类型和实际返回值不匹配，例如声明 int 却试图返回字符串。
以为修改函数形参就能直接改掉调用方变量，忽略了值传递的本质。
函数职责过大，既做输入输出又做计算又做状态修改，后面会很难测试和复用。
只在一个源文件里写了声明，却忘了把真正实现的源文件加入编译或链接命令。

3.4 作用域规则

Mon, 13 Apr 2026 15:30:00 +0800

作用域规则

概念说明

作用域决定了一个名字在程序的哪些位置可以被访问。在 C 语言里，常见的作用域包括块作用域和文件作用域，不同位置定义的变量可见范围不同。

作用域只回答“这里能不能访问这个名字”，并不等于“对象现在还活着”。比如局部 static 变量的生命周期覆盖整个程序运行过程，但它的名字仍然只在局部块中可见。

如果内层代码定义了和外层同名的变量，内层名字会暂时遮蔽外层名字。这类问题编译通常不会报错，但很容易让程序行为和预期不一致。

语法/规则

在花括号内部定义的局部变量，通常只在当前代码块内可见。
在函数外定义的全局变量，通常从定义位置开始到文件末尾可见。
内层代码块可以定义与外层同名的变量，这会发生遮蔽。
文件作用域名字如果不加 static，通常可以被其他源文件通过 extern 引用。
作用域和生命周期不是同一回事，局部 static 变量就是典型例子。
块级变量的意义通常越局部越好，这样更不容易误用。
同名变量过多会显著降低可读性，尤其是在嵌套代码块中。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>

int value = 100;

int main(void) {
 int value = 10;

 printf("inner value = %d\n", value);
 {
 int value = 1;
 printf("block value = %d\n", value);
 }

 return 0;
}

输出结果：

1
2


inner value = 10
block value = 1

这里最外层的全局 value 被 main 里的局部 value 遮蔽，而局部 value 又被内部块里的同名变量再次遮蔽。

常见错误

忘记变量遮蔽，误以为当前使用的是外层变量。
在代码块外访问块内变量，结果直接编译报错。
把“能访问到”误解成“生命周期还在”，忽略了对象实际已经失效的问题。
在多个层级重复使用相同变量名，导致阅读和调试都变得困难。
用全局变量解决本可以通过参数传递解决的问题，扩大了名字的可见范围和耦合面。

3.5 递归与可变参数

Mon, 13 Apr 2026 15:30:00 +0800

递归与可变参数

概念说明

递归是函数在定义中直接或间接调用自己。它适合描述具有相同子结构的问题，但必须有明确的结束条件，否则会无限调用下去。

递归的表达能力很强，但代价也很真实。每多递归一层，就会多一层函数调用开销和栈空间消耗，所以它并不适合所有问题。

可变参数函数允许参数个数不固定，常见于 printf 这类接口。在 C 里，这类函数通常要借助 stdarg.h 提供的 va_list、va_start、va_arg 和 va_end。

语法/规则

递归函数至少需要“递归推进”和“终止条件”两个部分。
如果递归深度较大，要考虑栈空间和重复计算带来的成本。
可变参数函数通常至少需要一个固定参数，用来描述后续参数的个数或格式。
va_arg 读取参数时必须使用正确类型，否则结果不可预期。
传入可变参数时要注意默认参数提升，例如 char、short 会提升为 int。
处理完可变参数后要调用 va_end 完成收尾。
如果一个问题能用简单循环表达，就不必为了“高级感”强行使用递归。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <stdarg.h>
#include <stdio.h>

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

int sum_ints(int count, ...) {
 va_list args;
 int sum = 0;

 va_start(args, count);
 for (int i = 0; i < count; i++) {
 sum += va_arg(args, int);
 }
 va_end(args);

 return sum;
}

int main(void) {
 printf("factorial = %d\n", factorial(5));
 printf("sum = %d\n", sum_ints(4, 1, 2, 3, 4));
 return 0;
}

输出结果：

1
2


factorial = 120
sum = 10

常见错误

递归函数没有正确结束条件，导致栈不断增长直到程序崩溃。
把本可复用的递归结果反复重复计算，导致时间开销急剧上升。
va_arg 读取的类型和实际传入类型不一致，造成未定义行为。
写了可变参数函数却没有额外信息来判断参数个数，导致读取边界不清楚。
忘记调用 va_end，或者在读取完成后继续使用已经失效的 va_list。

4.1 数组

Mon, 13 Apr 2026 15:30:00 +0800

数组

概念说明

数组是一组连续存放的同类型元素。它特别适合保存成绩、温度、坐标、字符序列这类“数量固定或可预估”的同类数据。

数组最关键的两个特征是：

元素类型相同。
内存连续排列。

这也是为什么数组访问效率高，但长度管理相对死板。普通数组一旦定义，长度通常就固定下来了；如果想插入、删除或扩容，往往需要自己移动元素或重新分配空间。

语法/规则

一维数组定义形式是 类型数组名[元素个数];。
数组初始化可以写成 int nums[3] = {1, 2, 3};，也可以省略长度让编译器推断。
数组下标从 0 开始，到 长度 - 1 结束。
在定义数组的同一作用域内，常见长度写法是 sizeof(arr) / sizeof(arr[0])。
数组名在很多表达式中会退化为首元素指针，但数组和指针并不是完全等价的东西。
普通数组不会自动扩容，也不会自动检查越界。
查找、统计、排序这类算法题，通常都会以数组为基础数据结构。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>

int main(void) {
 int scores[] = {78, 82, 90, 86, 94};
 int len = (int)(sizeof(scores) / sizeof(scores[0]));
 int sum = 0;
 int max = scores[0];

 for (int i = 0; i < len; i++) {
 sum += scores[i];
 if (scores[i] > max) {
 max = scores[i];
 }
 }

 printf("sum = %d\n", sum);
 printf("max = %d\n", max);
 return 0;
}

输出结果：

1
2


sum = 430
max = 94

常见错误

把数组长度和最后一个下标混淆，例如长度为 5 却访问 scores[5]。
以为数组会像高级语言容器一样自动扩容，结果直接写出了越界访问。
在函数里用 sizeof(arr) 计算传入数组长度，忘了它往往已经退化成指针。
插入或删除元素时只改了长度变量，却没有真正移动后续元素。
只验证中间位置的数据，没有专门检查第一个元素和最后一个元素的边界。

4.2 枚举与typedef

Mon, 13 Apr 2026 15:30:00 +0800

枚举与typedef

概念说明

枚举用于给一组离散整数值起有语义的名字。 typedef 用于给已有类型起别名，让复杂类型写起来更简洁。

这两者都不会改变底层数据的本质，但它们能明显提升代码可读性。尤其是在状态机、协议字段、结构体别名和回调类型定义场景里，非常常见。

学这一节时可以抓住两点：

enum 更像“带语义的整数常量集合”。
typedef 更像“给现有类型起一个更顺手的名字”。

语法/规则

枚举定义形式是 enum 枚举名 { 成员1, 成员2, ... };。
枚举成员默认从 0 开始递增，也可以手动指定某个成员的值。
typedef 原类型别名; 用来为已有类型创建别名。
typedef struct Student Student; 是 C 项目里很常见的写法。
枚举值适合和 switch 搭配使用，让分支逻辑更清楚。
typedef 不会创建一种全新的底层类型，它通常只是别名。
对外部协议或文件格式中的固定数值，最好显式指定枚举值，避免后续维护时顺序变化。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>

typedef unsigned int u32;

enum Day {
 MONDAY = 1,
 TUESDAY,
 WEDNESDAY
};

int main(void) {
 enum Day today = WEDNESDAY;
 u32 count = 3;

 printf("today = %d\n", today);
 printf("count = %u\n", count);
 return 0;
}

输出结果：

1
2


today = 3
count = 3

常见错误

以为 typedef 会创建一种完全新的底层类型，实际上它通常只是别名。
把枚举当字符串使用，忘了它本质上仍然是整数常量集合。
枚举值需要跨系统协议传输时，不明确指定数值，后面维护成本会变高。
在复杂声明里滥用 typedef，结果把真实类型结构藏得太深，阅读者反而更难理解。
用普通整数到处表示状态，却没有使用枚举把语义明确下来。

4.3 指针

Mon, 13 Apr 2026 15:30:00 +0800

指针

概念说明

指针本质上是保存地址的变量。通过指针，程序可以间接访问另一块内存中的数据，这也是 C 语言能高效操作数组、字符串和动态内存的关键原因。

理解指针时，最好分清三件事：

变量自己的值。
变量的地址。
指针里保存的地址。

这三者混在一起时，很多指针题看起来就会很乱。一旦把它们拆开理解，指针其实只是“先拿地址，再通过地址访问数据”的过程。

语法/规则

取地址运算符是 &，解引用运算符是 *。
指针定义形式是 类型 *指针名;，例如 int *p;。
指针类型应和目标对象类型匹配，否则解引用结果可能错误。
空指针通常写作 NULL，在使用前应先判断是否为空。
void * 可以保存任意对象地址，但在解引用前通常需要先转换成具体类型。
指针加减法的步长由它指向的数据类型决定，例如 int *p 每次 p + 1 会跨过一个 int。
指针运算和比较应尽量限定在同一数组或同一对象范围内，超出范围会非常危险。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <stdio.h>

void swap(int *a, int *b) {
 int temp = *a;
 *a = *b;
 *b = temp;
}

int main(void) {
 int x = 3;
 int y = 8;
 int nums[3] = {10, 20, 30};
 int *p = nums;

 swap(&x, &y);

 printf("x = %d\n", x);
 printf("y = %d\n", y);
 printf("second = %d\n", *(p + 1));
 return 0;
}

输出结果：

1
2
3


x = 8
y = 3
second = 20

这个例子既展示了“通过指针修改外部变量”，也展示了“数组名退化为指针后可参与指针运算”的常见用法。

常见错误

指针变量声明了却没有初始化，就直接解引用使用。
取地址和解引用混淆，例如该写 &x 时写成了 x。
以为所有指针都能随意强转后正常使用，忽略了类型、对齐和对象真实布局的风险。
free 之后继续使用旧指针，或者返回了已经失效局部对象的地址。
指针运算超出了原有数组边界，却还把结果当成合法地址继续访问。

4.4 函数指针与回调函数

Mon, 13 Apr 2026 15:30:00 +0800

函数指针与回调函数

概念说明

函数指针是“指向函数的指针”，它保存的是函数入口地址。有了函数指针，我们就可以把一个函数当作参数传给另一个函数，这种写法通常叫回调函数。

回调并不神秘，本质上就是“把某个动作延后到别处执行”。排序、事件处理、状态机、策略选择等场景里都很常见。

初学者最容易卡住的点不是“回调思想”，而是声明语法。这时可以先抓住括号：int (*op)(int, int) 中，op 是一个指针，它指向“参数为两个 int、返回 int”的函数。

语法/规则

函数指针声明要写清返回类型和参数列表，例如 int (*op)(int, int);。
函数名在很多表达式里会退化为函数地址，因此传参时可以直接写函数名。
通过函数指针调用函数时，op(1, 2) 和 (*op)(1, 2) 都常见。
回调函数的签名必须和函数指针类型匹配。
如果声明太难读，可以配合 typedef 给函数指针取别名，提升可读性。
函数指针和普通数据指针是不同概念，不要混用。
回调通常只负责“做什么”，调用时机和参数准备则由外层函数控制。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>

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

int sub(int a, int b) {
 return a - b;
}

int apply(int (*op)(int, int), int a, int b) {
 return op(a, b);
}

int main(void) {
 printf("add = %d\n", apply(add, 3, 4));
 printf("sub = %d\n", apply(sub, 3, 4));
 return 0;
}

输出结果：

1
2


add = 7
sub = -1

常见错误

忘了在声明里给 *op 加括号，导致类型含义完全变掉。
把函数返回值传进去，而不是把函数本身传进去。
回调参数签名不一致，编译器可能警告，运行时也可能出现更隐蔽的问题。
一看到函数指针就害怕，结果错过了很多“把行为参数化”的简洁写法。
在回调设计里把职责边界写乱，导致外层函数和回调函数都在做同一件事。

4.5 字符串

Mon, 13 Apr 2026 15:30:00 +0800

字符串

概念说明

C 语言里的字符串本质上是以空字符 \0 结尾的字符数组。也就是说，字符串并不是一个独立的内建类型，而是一种约定好的内存布局。

理解这一点后，很多常见问题就更容易解释：

为什么字符串需要为结尾的 \0 预留空间。
为什么比较字符串不能直接用 ==。
为什么拷贝字符串时容易越界。

还要分清两个常见写法：

char name[] = "Tom";：可修改的字符数组副本。
const char *name = "Tom";：指向字符串字面量的指针，通常不应修改内容。

语法/规则

字符串字面量例如 "hello"，底层会包含结尾的 \0。
常见字符串函数位于 <string.h>，例如 strlen、strcmp、strcpy、strcat、strchr。
用字符数组保存可修改字符串时，要给 \0 预留空间。
比较字符串内容应使用 strcmp，而不是直接使用 ==。
strlen 统计的是 \0 之前的字符个数，不包含终止符本身。
读取整行文本时，通常 fgets 比 scanf("%s", ...) 更稳妥。
对于拼接和格式化构造字符串，snprintf 往往比无长度控制的接口更安全。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


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

int main(void) {
 char name[20] = "C language";
 char copy[20];

 snprintf(copy, sizeof(copy), "%s", name);

 printf("text = %s\n", copy);
 printf("length = %zu\n", strlen(copy));
 printf("same = %d\n", strcmp(name, copy) == 0);
 return 0;
}

输出结果：

1
2
3


text = C language
length = 10
same = 1

常见错误

忘记为字符串结尾的 \0 预留空间，导致越界写入。
用 == 比较两个字符串内容，而不是使用 strcmp。
把字符串字面量当成可写数组去修改，结果触发未定义行为。
使用 strcpy、strcat 这类函数时没有确认目标缓冲区是否足够大。
混淆“字符数组”和“指向字符串的指针”，导致修改权限和生命周期判断出错。

4.6 二维数组与变长数组

Tue, 14 Apr 2026 00:00:00 +0800

二维数组与变长数组

概念说明

二维数组可以看成“数组的数组”。它常用于矩阵、表格、成绩单、棋盘和坐标网格这类同时需要行列两个维度的数据。

虽然我们会把二维数组想象成表格，但它在内存里仍然是连续存放的。 C 语言采用按行存储的方式，也就是先存完第 0 行，再存第 1 行，依此类推。

变长数组（VLA）则允许使用运行时变量指定数组长度。它是 C99 引入的能力，可以让某些“长度运行时才知道”的场景更简洁，但要注意编译器支持情况和栈空间大小。

语法/规则

二维数组定义形式通常是 类型数组名[行数][列数];。
二维数组在内存里按行连续存放，因此遍历时通常也按行访问更自然。
将二维数组传给函数时，除了最左侧维度，后续维度通常需要已知，例如 int sum(int arr[][3], int rows)。
int a[2][3] 可以理解为“包含 2 个元素的一维数组，而每个元素又是 int[3]”。
变长数组写法例如 int n = 5; int nums[n];，长度在运行时确定。
VLA 通常分配在自动存储区，过大的 VLA 可能导致栈空间压力过大。
C11 以后 VLA 变成可选特性，写可移植代码时要确认目标编译器是否支持。

示例

二维数组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>

int main(void) {
 int scores[2][3] = {
 {80, 75, 92},
 {61, 65, 71}
 };
 int total = 0;

 for (int row = 0; row < 2; row++) {
 for (int col = 0; col < 3; col++) {
 total += scores[row][col];
 }
 }

 printf("total = %d\n", total);
 return 0;
}

输出结果：

1

total = 444

变长数组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>

int main(void) {
 int n = 5;
 int nums[n];
 int sum = 0;

 for (int i = 0; i < n; i++) {
 nums[i] = i + 1;
 sum += nums[i];
 }

 printf("sum = %d\n", sum);
 return 0;
}

输出结果：

1

sum = 15

常见错误

以为二维数组在内存中真的是“分散的多行对象”，忽略了它实际上按行连续存放。
把二维数组传给函数时省略列数，结果函数形参类型不完整。
把 int ** 当成 int[行][列] 的通用替代类型，它们在内存模型上并不等价。
创建过大的变长数组，导致栈空间压力过大甚至程序崩溃。
在依赖较强可移植性的项目里使用 VLA，却没有确认编译器和标准支持情况。

4.7 数组指针、指针数组与二级指针

Tue, 14 Apr 2026 00:00:00 +0800

数组指针、指针数组与二级指针

概念说明

这一节最容易混淆的不是概念本身，而是声明语法太像。可以先用一句话区分三类写法：

int (*p)[3]：p 是“指向数组的指针”，常叫数组指针。
int *p[3]：p 是“由 3 个指针组成的数组”，常叫指针数组。
int **pp：pp 是“指向一级指针的指针”，也就是二级指针。

真正读懂这些写法的关键，是记住 [] 的优先级高于 *。所以很多时候，括号不是装饰，而是决定类型含义的必要部分。

这些类型都不是为了“故意刁难语法”。它们在字符串列表、二维数组、命令行参数和需要间接修改指针本身的场景里都非常常见。

语法/规则

int (*p)[3] 表示 p 指向一个包含 3 个 int 的数组。
int *p[3] 表示 p 是一个数组，其中每个元素都是 int *。
int **pp 表示 pp 指向一个 int * 类型对象。
char *argv[] 本质上就是一个指针数组，因此命令行参数天然和这部分知识有关。
二维数组常和数组指针配合，例如 int (*row)[4] = matrix;。
int ** 不能直接替代二维数组指针，因为它们期望的内存布局不同。
读复杂声明时，可以从变量名开始向外看，优先判断它是“数组”还是“指针”。

示例

指针数组

1
2
3
4
5
6
7


#include <stdio.h>

int main(void) {
 char *names[] = {"Tom", "Ada", "Lin"};
 printf("second = %s\n", names[1]);
 return 0;
}

输出结果：

1

second = Ada

数组指针和二级指针

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>

int main(void) {
 int matrix[2][3] = {
 {1, 2, 3},
 {4, 5, 6}
 };
 int value = 10;
 int *p = &value;
 int **pp = &p;
 int (*row)[3] = matrix;

 printf("matrix[1][2] = %d\n", row[1][2]);
 printf("value = %d\n", **pp);
 return 0;
}

输出结果：

1
2


matrix[1][2] = 6
value = 10

常见错误

忘记 [] 的优先级高于 *，结果把数组指针和指针数组完全看反。
在二维数组场景里误用 int **，导致类型不匹配或访问方式错误。
看见两个星号就只记“更复杂的指针”，却没弄清它到底指向的是什么类型。
复杂指针声明里省略必要括号，结果声明含义和自己想的完全不同。
没把“变量名往外读”的习惯建立起来，导致每次遇到复杂声明都只能硬背。

5.1 结构体

Mon, 13 Apr 2026 15:30:00 +0800

结构体

概念说明

结构体用于把多个不同类型的字段组织成一个整体。当一条数据不再只是单独的整数或字符串，而是“编号、姓名、成绩”这种多属性组合时，结构体就很适合。

结构体是 C 语言进行数据建模的重要方式。后面的链表、树、网络包、配置项等复杂数据结构，很多都会以结构体为基础。

结构体既可以单独使用，也可以和数组、指针、函数参数组合。所以学结构体时，不只是会写 struct，还要会处理结构体数组和结构体指针。

语法/规则

结构体定义形式是 struct 结构体名 { 字段列表 };。
访问普通结构体变量成员使用 .，访问结构体指针成员使用 ->。
结构体可以在定义时初始化，也可以后续逐个字段赋值。
结构体数组适合表示一组同构但多字段的数据。
结构体作为函数参数时可以按值传递，也可以传指针；数据较大时传指针更常见。
结构体内存布局可能包含对齐和填充，不能随意假设字段紧密排列。
如果结构体名称写起来太长，可以配合 typedef 提升可读性。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>

struct Student {
 int id;
 double score;
};

int main(void) {
 struct Student group[2] = {
 {1001, 92.5},
 {1002, 87.0}
 };
 struct Student *first = &group[0];

 printf("first id = %d\n", first->id);
 printf("first score = %.1f\n", first->score);
 printf("second score = %.1f\n", group[1].score);
 return 0;
}

输出结果：

1
2
3


first id = 1001
first score = 92.5
second score = 87.0

常见错误

结构体变量和结构体指针混用，把 . 和 -> 写反。
误以为结构体字段一定紧挨着排列，忽略了内存对齐和填充。
只图方便把无关字段全部塞进一个结构体，结果模型越来越混乱。
复制结构体时没有意识到这是按字段整体复制，而不是共享同一份对象。
结构体数组下标和成员访问一起使用时，没有先把表达式读清楚，导致访问错位。

5.2 共用体

Mon, 13 Apr 2026 15:30:00 +0800

共用体

概念说明

共用体和结构体一样，也能把多个成员组织在一起。但共用体的所有成员共享同一块内存，因此同一时刻通常只适合把其中一个成员当成有效值来使用。

这让共用体在节省空间、做协议解析或与底层数据布局交互时很有用。不过它的使用前提是你必须非常清楚当前内存里到底按哪种成员解释。

在实际项目里，如果要安全表达“当前到底是哪一种值”，通常会把 union 和一个额外的标签字段搭配使用，也就是所谓的 tagged union 思路。

语法/规则

共用体定义形式是 union 共用体名 { 成员列表 };。
共用体大小通常由最大成员决定，并受对齐规则影响。
给某个成员赋值后，再读取另一个成员的结果要格外谨慎。
共用体适合“同一段内存的不同解释方式”，不适合同时保存多份独立数据。
如果程序里需要知道“当前有效成员是谁”，最好配合枚举标签一起使用。
用共用体做底层技巧时，要特别注意可移植性和未定义行为边界。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>

enum ValueType {
 VALUE_INT,
 VALUE_FLOAT
};

struct TaggedValue {
 enum ValueType type;
 union {
 int i;
 float f;
 } data;
};

int main(void) {
 struct TaggedValue first = {VALUE_INT, {.i = 10}};
 struct TaggedValue second = {VALUE_FLOAT, {.f = 3.5f}};

 printf("first = %d\n", first.data.i);
 printf("second = %.1f\n", second.data.f);
 return 0;
}

输出结果：

1
2


first = 10
second = 3.5

常见错误

像使用结构体一样，期望共用体所有成员同时都保留自己的值。
写入一个成员后直接把另一成员解释成可靠结果，却没有确认这样做是否安全。
只是为了“省几个字节”盲目使用共用体，结果让代码可读性和可维护性变差。
没有额外标签来记录当前有效成员，导致后续读取时完全靠猜。
直接把共用体技巧当成通用跨平台方案，而没有考虑编译器和平台差异。

5.3 位域

Mon, 13 Apr 2026 15:30:00 +0800

位域

概念说明

位域允许把结构体成员按“多少位”来分配，而不是按完整字节或完整整型分配。它常用于状态标记、硬件寄存器映射和协议字段这类需要节省空间的场景。

位域确实方便，但它和平台实现、编译器布局关系较强。所以它更适合明确受控的底层场景，不适合拿来做强可移植的数据交换格式。

从使用体验上看，位域像是“语法层面的位掩码包装”。它能让字段访问更直观，但在可移植性和地址操作上没有普通成员那么自由。

语法/规则

位域通常写在结构体里，形式是 unsigned int flag : 1;。
冒号后的数字表示该成员占用的位数。
位域宽度不能随意超出底层类型可提供的位数。
位域的内存布局、对齐和排列顺序与实现有关。
位域成员通常不能像普通成员那样直接取地址。
当你非常在意跨平台一致性时，手动使用位掩码往往比位域更可控。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>

struct Status {
 unsigned int is_open : 1;
 unsigned int is_error : 1;
 unsigned int level : 2;
};

int main(void) {
 struct Status status = {1, 0, 3};

 printf("is_open = %u\n", status.is_open);
 printf("is_error = %u\n", status.is_error);
 printf("level = %u\n", status.level);
 return 0;
}

输出结果：

1
2
3


is_open = 1
is_error = 0
level = 3

常见错误

以为位域布局在所有平台和编译器上都完全一致。
试图对位域成员取地址，忽略了它们并不总是普通独立对象。
给位域赋超出可表示范围的值，却没有意识到高位会被截断。
把位域直接拿来描述网络协议或文件格式，却没有验证实际字节布局。
位域和位运算概念混在一起，导致调试时很难判断问题到底在布局还是在掩码逻辑。

5.4 内存管理

Mon, 13 Apr 2026 15:30:00 +0800

内存管理

概念说明

C 语言允许程序员主动向堆区申请和释放内存。这让程序能处理运行时才知道大小的数据，但也意味着你要自己负责释放资源和避免非法访问。

学动态内存时，光记住函数名远远不够。更重要的是建立“资源所有权”的意识：是谁申请的、谁负责释放、失败时怎么兜底、释放后还能不能继续使用旧地址。

还可以先区分两类常见内存：

自动存储区：例如普通局部变量，通常跟随作用域自动创建和销毁。
堆区：通过 malloc 这类接口显式申请，必须手动释放。

语法/规则

malloc(size) 按字节申请一块未初始化的内存。
calloc(count, size) 会申请并清零一块内存。
realloc(ptr, new_size) 用于调整原内存块大小，可能返回新地址。
free(ptr) 释放动态内存；释放后不应再继续使用该地址。
申请内存后必须先检查返回值是否为 NULL。
调整内存大小时，最好先用临时指针接收 realloc 返回值，避免原指针丢失。
动态数组的字节数通常写成 元素个数 * sizeof(元素类型)，而不是手写魔法数字。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


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

int main(void) {
 int *nums = malloc(3 * sizeof(int));
 if (nums == NULL) {
 return 1;
 }

 nums[0] = 10;
 nums[1] = 20;
 nums[2] = 30;

 int *tmp = realloc(nums, 5 * sizeof(int));
 if (tmp == NULL) {
 free(nums);
 return 1;
 }
 nums = tmp;

 nums[3] = 40;
 nums[4] = 50;

 printf("sum = %d\n", nums[0] + nums[1] + nums[2] + nums[3] + nums[4]);

 free(nums);
 nums = NULL;
 return 0;
}

输出结果：

1

sum = 150

常见错误

申请了内存却忘记释放，造成内存泄漏。
free 之后继续读写同一块内存，形成 use-after-free。
申请大小写错，例如忘了乘 sizeof(元素类型)，导致缓冲区过小。
直接把 realloc 返回值赋给原指针，失败时把原地址也丢了。
对同一块内存重复 free，或者释放了根本不是动态申请得到的地址。

5.5 未定义行为

Mon, 13 Apr 2026 15:30:00 +0800

未定义行为

概念说明

未定义行为表示 C 标准没有规定某段代码必须产生什么结果。一旦程序进入这种状态，可能“看起来能跑”、可能输出随机结果，也可能在不同编译器或优化级别下表现完全不同。

很多初学者会把未定义行为理解成“只是不太稳定”。实际上更准确的理解是：你已经离开了语言保证的范围，后续任何现象都不值得依赖。

这也是为什么 C 程序的调试不能只看一次运行结果。某段代码今天在你的电脑上“似乎没问题”，并不代表它就是合法写法。

语法/规则

使用未初始化局部变量、数组越界、空指针解引用，都可能触发未定义行为。
有符号整数溢出、释放后继续访问内存，也是常见未定义行为来源。
某段代码在你电脑上“每次都一样”，不代表它就是合法行为。
预防未定义行为的关键是初始化、边界检查、资源管理和减少危险写法。
编译优化会放大未定义行为带来的不可预测后果，因此 Debug 和 Release 结果可能差异很大。
警告、静态分析和运行时检测工具能帮助你更早发现这类问题，但前提仍是代码本身要尊重边界。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


#include <stdio.h>

int main(void) {
 int nums[3] = {1, 2, 3};
 int index = 2;

 if (index >= 0 && index < 3) {
 printf("value = %d\n", nums[index]);
 }

 return 0;
}

输出结果：

1

value = 3

这个例子之所以安全，不是因为数组天生安全，而是因为在访问前明确做了边界检查。

常见错误

依赖某次运行碰巧得到的“正确结果”，把未定义行为当成正常逻辑继续使用。
只在 Debug 模式下观察结果，就断定发布版本也会完全一样。
遇到越界、野指针、释放后访问这类问题时，只修表面现象，不追根因。
觉得“编译器没报错就说明没问题”，忽略了很多未定义行为本来就未必会在编译期暴露。
在高优化级别下出现诡异结果时，只怀疑编译器，而不先检查代码是否已经越过语言保证边界。

5.6 位运算与字节序

Tue, 14 Apr 2026 00:00:00 +0800

位运算与字节序

概念说明

位运算是直接对整数的二进制位进行操作。它常用于标志位管理、权限控制、协议解析、硬件寄存器操作和某些性能敏感场景。

字节序讨论的则是“多字节数据在内存中按什么顺序存放”。最常见的两种是：

大端序：高位字节放在低地址。
小端序：低位字节放在低地址。

只有当你真正把一个多字节对象拆成字节去看，或者要和网络、文件、外设打交道时，字节序问题才会变得重要。

语法/规则

常见位运算符有 &、|、^、~、<<、>>。
& 常用于保留某些位，| 常用于设置某些位，^ 常用于翻转某些位。
位运算通常更适合搭配无符号整数使用，避免有符号移位带来的歧义。
左移和右移的位数必须合理，移位过大或对负数做不当移位都可能有风险。
处理标志位时，最好为每个掩码取有语义的名字，而不是直接写裸数字。
字节序不会影响一个整数按整数方式使用时的值，但会影响把它按字节解释时的顺序。
网络协议和跨平台二进制文件通常需要明确规定字节序，不能默认所有环境都和自己机器一样。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <stdio.h>

enum {
 FLAG_READ = 1 << 0,
 FLAG_WRITE = 1 << 1,
 FLAG_EXEC = 1 << 2
};

int main(void) {
 unsigned int flags = 0;
 unsigned int value = 1;
 unsigned char *bytes = (unsigned char *)&value;

 flags |= FLAG_READ;
 flags |= FLAG_WRITE;

 printf("can_read = %u\n", (flags & FLAG_READ) != 0);
 printf("can_write = %u\n", (flags & FLAG_WRITE) != 0);
 printf("can_exec = %u\n", (flags & FLAG_EXEC) != 0);
 printf("endianness = %s\n", bytes[0] == 1 ? "little" : "big");
 return 0;
}

输出结果：

1
2
3
4


can_read = 1
can_write = 1
can_exec = 0
endianness = little

endianness 这一行在常见的 x86/x64 平台上通常会输出 little。如果换到大端机器上，结果就可能不同，这正是字节序相关代码需要注意的平台差异。

常见错误

把位运算符 &、| 和逻辑运算符 &&、|| 混为一谈。
对有符号整数做复杂移位操作，却没有意识到结果可能受实现影响。
使用裸数字掩码，例如 flags |= 4，导致代码语义不清晰。
只在本机测试过二进制格式，就默认所有平台的字节顺序都和当前机器一致。
以为字节序会影响“整数本身的数学值”，却没区分“按对象使用”和“按字节解释”这两种场景。

6.1 输入与输出

Mon, 13 Apr 2026 15:30:00 +0800

输入与输出

概念说明

C 标准库通过 <stdio.h> 提供了基础输入输出能力。程序最常接触的三条标准流分别是：

stdin：标准输入
stdout：标准输出
stderr：标准错误输出

终端输出最常见的是 printf、puts 和 putchar，终端输入最常见的是 scanf、getchar 和 fgets。这些接口看起来都很基础，但一旦遇到格式控制、缓冲区长度和换行残留，就很容易出问题。

语法/规则

printf 用格式化占位符输出数据，例如 %d、%u、%f、%c、%s、%zu。
scanf 读取普通变量时，大多数情况下要传地址，例如 &age。
读取字符串时应限制长度，例如 %19s，避免缓冲区溢出。
需要读取整行文本时，fgets 往往比 scanf("%s", ...) 更适合。
getchar 适合逐字符读取输入，putchar 适合逐字符输出。
scanf 有返回值，应该用它判断本次是否成功读到期望数量的数据。
混用 scanf 和 fgets 时，要特别小心输入缓冲区中残留的换行符。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <stdio.h>

int main(void) {
 char name[20];
 int age;

 printf("请输入姓名和年龄：");
 if (scanf("%19s %d", name, &age) != 2) {
 return 1;
 }

 printf("name = %s, age = %d\n", name, age);
 return 0;
}

输出结果：

1
2


请输入姓名和年龄：alice 20
name = alice, age = 20

常见错误

用 scanf 读取普通变量时忘记传地址，例如把 &age 写成 age。
读取字符串时不限制长度，导致缓冲区溢出风险。
混用 scanf 和 fgets 时不处理残留换行，结果下一次读取直接得到空行。
使用错误的格式控制符，导致输出错乱或输入解析失败。
只关心读取动作本身，却不检查返回值，结果在输入不合法时继续使用脏数据。

6.2 文件读写

Mon, 13 Apr 2026 15:30:00 +0800

文件读写

概念说明

文件操作让程序的数据可以脱离内存，在程序结束后仍然保留下来。 C 标准库通过 FILE * 表示打开的文件流，并提供一组函数完成读写、定位和关闭。

文件处理大致可以分成几类：

文本读写：例如 fgets、fputs、fprintf、fscanf
二进制块读写：例如 fread、fwrite
随机定位：例如 fseek、ftell、rewind

学文件时一定要把“模式对吗、打开成功了吗、最后关闭了吗”当成固定检查项。这类问题如果忽略，程序往往不是编译时报错，而是运行时行为异常。

语法/规则

fopen 用于打开文件，常见模式有 r、w、a、rb、wb、ab。
打开文件后要检查返回值是否为 NULL。
文本写入常见函数有 fputs、fprintf，文本读取常见函数有 fgets、fscanf。
二进制块读写常见函数有 fread 和 fwrite。
随机读写常配合 fseek、ftell、rewind 使用。
feof 和 ferror 用于辅助判断读写结束原因，不应先用 feof 预测下一次读取是否成功。
文件使用完毕后要调用 fclose 关闭；长期运行程序里，这一步尤其重要。

示例

文本文件读写

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>

int main(void) {
 char buffer[64];
 FILE *fp = fopen("demo.txt", "w");
 if (fp == NULL) {
 return 1;
 }

 fputs("hello file\n", fp);
 fclose(fp);

 fp = fopen("demo.txt", "r");
 if (fp == NULL) {
 return 1;
 }

 fgets(buffer, sizeof(buffer), fp);
 fclose(fp);

 printf("%s", buffer);
 return 0;
}

输出结果：

1

hello file

二进制块读写与定位

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <stdio.h>

int main(void) {
 int values[5] = {10, 20, 30, 40, 50};
 int target = 0;
 FILE *fp = fopen("numbers.bin", "wb");
 if (fp == NULL) {
 return 1;
 }

 fwrite(values, sizeof(int), 5, fp);
 fclose(fp);

 fp = fopen("numbers.bin", "rb");
 if (fp == NULL) {
 return 1;
 }

 fseek(fp, 2L * (long)sizeof(int), SEEK_SET);
 fread(&target, sizeof(int), 1, fp);
 fclose(fp);

 printf("third = %d\n", target);
 return 0;
}

输出结果：

1

third = 30

常见错误

fopen 失败后直接继续读写，导致空指针使用问题。
文件打开模式写错，例如本来想追加却用了 w，结果覆盖了原内容。
文本和二进制场景混用读写接口，却没有明确自己到底在处理什么格式的数据。
试图用 feof 预判下一次是否还能读，结果把循环控制写反。
忘记 fclose，长期运行程序里可能造成资源泄漏或数据未及时落盘。

6.3 预处理器与头文件

Mon, 13 Apr 2026 15:30:00 +0800

预处理器与头文件

概念说明

预处理器会在正式编译前先处理源码中的预处理指令。最常见的预处理任务包括头文件包含、宏替换和条件编译。

头文件的作用是共享声明。一个更像样的 C 项目通常会把函数声明、结构体声明和宏定义放进 .h 文件，再把具体实现放在 .c 文件中。

预处理并不等于“只是 include 一下”。它还会影响代码组织、调试信息输出、平台适配和编译开关控制，所以是 C 工程基础里非常关键的一部分。

语法/规则

#include <stdio.h> 常用于包含标准库头文件，#include "my.h" 常用于包含项目自己的头文件。
#define 会进行文本替换，编写宏时通常要给参数和整体表达式补括号。
函数式宏适合非常短小的表达式封装，但带副作用的参数要格外谨慎。
常见预定义宏有 __FILE__、__LINE__、__DATE__、__TIME__。
条件编译常见写法有 #if、#ifdef、#ifndef、#elif、#else、#endif。
defined 可用于配合 #if 检查某个宏是否已经定义。
头文件应加保护宏，避免被重复包含；必要时也可以用 #error 在配置不满足时直接阻止编译。

示例

1
2
3
4
5
6
7
8
9


/* math_tools.h */
#ifndef MATH_TOOLS_H
#define MATH_TOOLS_H

#define SQUARE(x) ((x) * (x))

int add(int a, int b);

#endif

1
2
3
4
5
6


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

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

1
2
3
4
5
6
7
8
9


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

int main(void) {
 printf("sum = %d\n", add(3, 4));
 printf("square = %d\n", SQUARE(3));
 return 0;
}

输出结果：

1
2


sum = 7
square = 9

常见错误

头文件没有保护宏，被重复包含后出现重复定义问题。
宏没有加括号，例如 #define SQUARE(x) x * x，在复杂表达式里结果会出错。
把大量实现代码直接塞进头文件，导致多文件编译和链接变得混乱。
用条件编译控制平台差异时没有把分支写完整，结果某些环境下直接编译不过。
在宏参数里传入带副作用的表达式，却没有意识到宏展开可能导致重复求值。

6.4 错误处理与安全函数

Mon, 13 Apr 2026 15:30:00 +0800

错误处理与安全函数

概念说明

C 语言默认没有像很多高级语言那样统一的异常机制。大多数标准库函数会通过返回值告诉你“成功还是失败”，必要时再借助 errno 补充更具体的错误原因。

所以，C 里的错误处理重点不是“出错以后再说”，而是每次调用都及时检查结果。文件操作、内存申请、字符串处理、格式化输入输出，都是最应该养成这个习惯的地方。

这里所谓的“安全函数”，更准确地说，是“边界意识更强的写法”。有时它表现为使用 snprintf、fgets、strtol 这类更容易做长度和错误检查的接口；有时也包括某些平台提供的 _s 系列函数，但后者并不是所有环境都统一支持。

语法/规则

调用可能失败的函数后，要先检查返回值，再决定是否继续执行。
errno 只有在函数已经明确失败时才有意义，不应在成功路径里随意读取它。
如果错误信息后面还要继续使用，最好先把 errno 保存到局部变量中，再调用 strerror 或 perror。
错误信息应优先输出到 stderr，不要和正常结果混在 stdout 中。
程序结束时可用 EXIT_SUCCESS 和 EXIT_FAILURE 表达退出状态，比直接写数字更清晰。
读取字符串时，fgets 往往比无长度控制的 gets 或 %s 更稳妥。
格式化拼接字符串时，snprintf 通常比 sprintf 更适合做边界控制。
解析数字时，strtol、strtod 一般比 atoi、atof 更容易检查错误。
_s 系列函数属于可选或平台相关能力，写可移植代码前应先确认支持情况。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


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

int main(void) {
 FILE *fp = fopen("not-exist.txt", "r");
 if (fp == NULL) {
 int err = errno;
 fprintf(stderr, "errno = %d\n", err);
 perror("fopen");
 fprintf(stderr, "message = %s\n", strerror(err));
 return EXIT_FAILURE;
 }

 fclose(fp);
 return EXIT_SUCCESS;
}

输出结果：

1
2
3


errno = 2
fopen: No such file or directory
message = No such file or directory

不同平台下的错误号和错误文本可能略有差异，但整体用法是一致的。

常见错误

读取 errno 之前不先确认函数是否失败，导致把旧错误当成新错误。
直接把错误输出到 stdout，让正常输出和错误输出混在一起。
使用 sprintf、strcpy、strcat 这类接口时完全不考虑目标缓冲区大小。
直接用 atoi 解析用户输入，却没有检测转换失败或溢出的情况。
以为 _s 后缀函数在所有平台都可直接使用，结果换编译器后无法通过编译。

6.5 命令行参数

Mon, 13 Apr 2026 15:30:00 +0800

命令行参数

概念说明

命令行参数允许程序在启动时接收外部输入，而不必每次运行后再交互式输入。这类方式非常适合脚本工具、批处理程序和命令行小工具。

在 C 里，main 函数常见的写法有两种：int main(int argc, char *argv[]) 和 int main(int argc, char **argv)。这两种写法在这里可以理解为等价，核心区别不在语义，而在写法风格。

其中 argc 表示参数个数，argv 表示参数字符串数组。程序名本身通常也会算作一个参数，所以即使用户没有额外传参，argc 一般也至少是 1。

语法/规则

main 常见写法是 int main(int argc, char *argv[]) 或 int main(int argc, char **argv)。
argc 至少为 1，因为程序名本身通常就占 argv[0]。
argv[0] 一般是程序名或程序路径，真正的用户参数从 argv[1] 开始读取。
使用参数前应先检查 argc，避免访问不存在的元素。
命令行参数默认都是字符串；如果要转成数字，strtol、strtod 一般比 atoi、atof 更适合做错误检查。
多个参数之间默认用空格分隔；如果单个参数本身包含空格，传参时通常要用引号包起来。
实际项目中，命令行参数常用于传递配置文件路径、输入输出文件名、调试开关和模式选项。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


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

int main(int argc, char *argv[]) {
 char *end1;
 char *end2;
 long a;
 long b;

 if (argc != 3) {
 fprintf(stderr, "usage: %s <a> <b>\n", argv[0]);
 return EXIT_FAILURE;
 }

 errno = 0;
 a = strtol(argv[1], &end1, 10);
 if (errno != 0 || *end1 != '\0') {
 fprintf(stderr, "invalid integer: %s\n", argv[1]);
 return EXIT_FAILURE;
 }

 errno = 0;
 b = strtol(argv[2], &end2, 10);
 if (errno != 0 || *end2 != '\0') {
 fprintf(stderr, "invalid integer: %s\n", argv[2]);
 return EXIT_FAILURE;
 }

 printf("program = %s\n", argv[0]);
 printf("sum = %ld\n", a + b);
 return EXIT_SUCCESS;
}

输出结果：

1
2
3


demo 3 4
program = demo
sum = 7

argv[0] 的实际内容和运行环境有关。有的平台会显示 demo，有的平台会显示 demo.exe，也有可能直接显示完整路径。

常见错误

不检查 argc 就直接使用 argv[1]、argv[2]，导致越界访问。
直接用 atoi 处理用户输入，却没有检测转换失败的情况。
忽略带空格参数需要加引号这一点，导致实参数量和预期不一致。
把 argv 里的字符串当成整数直接计算，却没有先完成合法转换。
在函数参数里对数组使用 sizeof 试图计算实参数量，结果得到的是指针大小而不是真实元素个数。

7.1 排序算法入门

Mon, 13 Apr 2026 15:30:00 +0800

排序算法入门

概念说明

排序算法的目标是把一组无序数据按升序或降序重新排列。
它是学习 C 语言时非常典型的综合练习，因为会把数组、循环、条件判断、函数、指针和临时空间管理串到一起。

C语言中文网的排序教程不只讲冒泡排序。
它还继续介绍了选择排序、插入排序、希尔排序、归并排序和快速排序，并且归并排序、快速排序都给出了迭代版与递归版思路。

学习这些排序的重点，不只是“把代码背下来”。
更重要的是理解每种排序靠什么维持局部有序、什么时候需要交换、什么时候需要移动元素，以及它们在时间复杂度、额外空间和稳定性上的差异。

语法/规则

排序函数通常接收两个参数：数组首元素地址和数组长度，因为函数内部无法直接知道传入数组原本有多长。
冒泡排序、选择排序、插入排序都属于基础的 O(n^2) 排序，适合教学和小规模数据处理。
希尔排序是插入排序的改进版，它通过“分组 + 缩小增量”减少元素移动次数。
归并排序使用分治思想，先拆分，再合并，时间复杂度通常是 O(n log n)，但需要额外辅助数组。
快速排序通常也能达到 O(n log n) 的平均性能，但如果基准选择不合适，最坏情况会退化到 O(n^2)。
归并排序和快速排序都可以写成递归版，也可以改写成显式栈或分段循环驱动的迭代版。
稳定排序会尽量保持“相等元素的原始先后顺序”；冒泡、插入、归并通常是稳定的，选择、希尔、快速通常不是。
写排序时最容易出错的地方是循环边界、分区边界、辅助数组长度和递归终止条件。

常见排序可以先按下面这张表建立整体印象：

算法	核心思路	平均时间复杂度	额外空间	稳定性
冒泡排序	相邻比较，较大元素逐步冒到后面	`O(n^2)`	`O(1)`	稳定
选择排序	每轮选最小值，再放到当前起始位置	`O(n^2)`	`O(1)`	不稳定
插入排序	维护前缀有序区，把新元素插进去	`O(n^2)`	`O(1)`	稳定
希尔排序	按增量分组做插入排序	依赖增量序列	`O(1)`	不稳定
归并排序	先分解再合并	`O(n log n)`	`O(n)`	稳定
快速排序	分区后分别处理左右两侧	`O(n log n)`	递归栈或显式栈	不稳定

示例

下面各个示例都使用同一组数据：

1

7 12 17 29 41 45 53 65 71 84 88 96

为了便于和原网站内容对照，下面分别补全每一种排序的最小可运行示例。

冒泡排序

冒泡排序会反复比较相邻元素。
如果前一个比后一个大，就交换它们。每完成一轮，当前未排序区间里最大的元素就会被“冒”到末尾。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#include <stdio.h>

void print_array(const int arr[], int len) {
 for (int i = 0; i < len; i++) {
 printf("%d ", arr[i]);
 }
 printf("\n");
}

void bubble_sort(int arr[], int len) {
 for (int i = 0; i < len - 1; i++) {
 for (int j = 0; j < len - 1 - i; j++) {
 if (arr[j] > arr[j + 1]) {
 int temp = arr[j];
 arr[j] = arr[j + 1];
 arr[j + 1] = temp;
 }
 }
 }
}

int main(void) {
 int arr[] = {29, 17, 45, 12, 53, 7, 84, 65, 96, 41, 71, 88};
 int len = (int)(sizeof(arr) / sizeof(arr[0]));

 bubble_sort(arr, len);
 print_array(arr, len);
 return 0;
}

输出结果：

1

7 12 17 29 41 45 53 65 71 84 88 96

选择排序

选择排序每一轮都会在未排序区间里找一个最小值。
找到后，把这个最小值交换到当前轮的起始位置。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


#include <stdio.h>

void print_array(const int arr[], int len) {
 for (int i = 0; i < len; i++) {
 printf("%d ", arr[i]);
 }
 printf("\n");
}

void selection_sort(int arr[], int len) {
 for (int i = 0; i < len - 1; i++) {
 int min_index = i;
 for (int j = i + 1; j < len; j++) {
 if (arr[j] < arr[min_index]) {
 min_index = j;
 }
 }
 if (min_index != i) {
 int temp = arr[min_index];
 arr[min_index] = arr[i];
 arr[i] = temp;
 }
 }
}

int main(void) {
 int arr[] = {29, 17, 45, 12, 53, 7, 84, 65, 96, 41, 71, 88};
 int len = (int)(sizeof(arr) / sizeof(arr[0]));

 selection_sort(arr, len);
 print_array(arr, len);
 return 0;
}

输出结果：

1

7 12 17 29 41 45 53 65 71 84 88 96

插入排序

插入排序会维护一个“前面已经有序”的区间。
每次取出一个新元素，把它插入到前面合适的位置，同时把较大的元素整体后移。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <stdio.h>

void print_array(const int arr[], int len) {
 for (int i = 0; i < len; i++) {
 printf("%d ", arr[i]);
 }
 printf("\n");
}

void insertion_sort(int arr[], int len) {
 for (int i = 1; i < len; i++) {
 int current = arr[i];
 int j = i;

 while (j > 0 && arr[j - 1] > current) {
 arr[j] = arr[j - 1];
 j--;
 }

 arr[j] = current;
 }
}

int main(void) {
 int arr[] = {29, 17, 45, 12, 53, 7, 84, 65, 96, 41, 71, 88};
 int len = (int)(sizeof(arr) / sizeof(arr[0]));

 insertion_sort(arr, len);
 print_array(arr, len);
 return 0;
}

输出结果：

1

7 12 17 29 41 45 53 65 71 84 88 96

希尔排序

希尔排序可以看作“带增量的插入排序”。
它先按较大的间隔把元素分组排序，再逐步缩小间隔，直到间隔为 1，相当于最后做一次更高效的插入排序。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


#include <stdio.h>

void print_array(const int arr[], int len) {
 for (int i = 0; i < len; i++) {
 printf("%d ", arr[i]);
 }
 printf("\n");
}

void shell_sort(int arr[], int len) {
 for (int gap = len / 2; gap > 0; gap /= 2) {
 for (int i = gap; i < len; i++) {
 int temp = arr[i];
 int j = i;

 while (j >= gap && arr[j - gap] > temp) {
 arr[j] = arr[j - gap];
 j -= gap;
 }

 arr[j] = temp;
 }
 }
}

int main(void) {
 int arr[] = {29, 17, 45, 12, 53, 7, 84, 65, 96, 41, 71, 88};
 int len = (int)(sizeof(arr) / sizeof(arr[0]));

 shell_sort(arr, len);
 print_array(arr, len);
 return 0;
}

输出结果：

1

7 12 17 29 41 45 53 65 71 84 88 96

归并排序（迭代法）

归并排序的迭代版不会递归拆分数组。
它会从长度为 1 的小段开始，两两合并成更大的有序段，再继续把更大的有序段合并起来。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


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

void print_array(const int arr[], int len) {
 for (int i = 0; i < len; i++) {
 printf("%d ", arr[i]);
 }
 printf("\n");
}

void merge(int arr[], int left, int mid, int right, int temp[]) {
 int i = left;
 int j = mid + 1;
 int k = left;

 while (i <= mid && j <= right) {
 if (arr[i] <= arr[j]) {
 temp[k++] = arr[i++];
 } else {
 temp[k++] = arr[j++];
 }
 }

 while (i <= mid) {
 temp[k++] = arr[i++];
 }

 while (j <= right) {
 temp[k++] = arr[j++];
 }

 for (i = left; i <= right; i++) {
 arr[i] = temp[i];
 }
}

void merge_sort_iterative(int arr[], int len) {
 int *temp = malloc((size_t)len * sizeof(int));
 if (temp == NULL) {
 return;
 }

 for (int size = 1; size < len; size *= 2) {
 for (int left = 0; left < len - size; left += 2 * size) {
 int mid = left + size - 1;
 int right = left + 2 * size - 1;

 if (right >= len) {
 right = len - 1;
 }

 merge(arr, left, mid, right, temp);
 }
 }

 free(temp);
}

int main(void) {
 int arr[] = {29, 17, 45, 12, 53, 7, 84, 65, 96, 41, 71, 88};
 int len = (int)(sizeof(arr) / sizeof(arr[0]));

 merge_sort_iterative(arr, len);
 print_array(arr, len);
 return 0;
}

输出结果：

1

7 12 17 29 41 45 53 65 71 84 88 96

归并排序（递归法）

归并排序的递归版更符合“分治”本来的表达方式。
它会先递归处理左半部分和右半部分，再把两段有序数组合并起来。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65


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

void print_array(const int arr[], int len) {
 for (int i = 0; i < len; i++) {
 printf("%d ", arr[i]);
 }
 printf("\n");
}

void merge(int arr[], int left, int mid, int right, int temp[]) {
 int i = left;
 int j = mid + 1;
 int k = left;

 while (i <= mid && j <= right) {
 if (arr[i] <= arr[j]) {
 temp[k++] = arr[i++];
 } else {
 temp[k++] = arr[j++];
 }
 }

 while (i <= mid) {
 temp[k++] = arr[i++];
 }

 while (j <= right) {
 temp[k++] = arr[j++];
 }

 for (i = left; i <= right; i++) {
 arr[i] = temp[i];
 }
}

void merge_sort_recursive_impl(int arr[], int left, int right, int temp[]) {
 if (left >= right) {
 return;
 }

 int mid = left + (right - left) / 2;
 merge_sort_recursive_impl(arr, left, mid, temp);
 merge_sort_recursive_impl(arr, mid + 1, right, temp);
 merge(arr, left, mid, right, temp);
}

void merge_sort_recursive(int arr[], int len) {
 int *temp = malloc((size_t)len * sizeof(int));
 if (temp == NULL) {
 return;
 }

 merge_sort_recursive_impl(arr, 0, len - 1, temp);
 free(temp);
}

int main(void) {
 int arr[] = {29, 17, 45, 12, 53, 7, 84, 65, 96, 41, 71, 88};
 int len = (int)(sizeof(arr) / sizeof(arr[0]));

 merge_sort_recursive(arr, len);
 print_array(arr, len);
 return 0;
}

输出结果：

1

7 12 17 29 41 45 53 65 71 84 88 96

快速排序（迭代法）

快速排序的关键是“分区”。
它会选一个基准值，把小于基准的元素放左边，大于基准的元素放右边。迭代版不会递归调用，而是用显式栈记录后续还要处理的区间。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79


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

typedef struct {
 int start;
 int end;
} Range;

void print_array(const int arr[], int len) {
 for (int i = 0; i < len; i++) {
 printf("%d ", arr[i]);
 }
 printf("\n");
}

int partition(int arr[], int start, int end) {
 int pivot = arr[end];
 int i = start - 1;

 for (int j = start; j < end; j++) {
 if (arr[j] <= pivot) {
 i++;
 int temp = arr[i];
 arr[i] = arr[j];
 arr[j] = temp;
 }
 }

 int temp = arr[i + 1];
 arr[i + 1] = arr[end];
 arr[end] = temp;
 return i + 1;
}

void quick_sort_iterative(int arr[], int len) {
 Range *stack;
 int top = -1;

 if (len <= 1) {
 return;
 }

 stack = malloc((size_t)len * sizeof(Range));
 if (stack == NULL) {
 return;
 }

 stack[++top] = (Range){0, len - 1};

 while (top >= 0) {
 Range current = stack[top--];
 int start = current.start;
 int end = current.end;

 if (start >= end) {
 continue;
 }

 int pivot_index = partition(arr, start, end);

 if (pivot_index - 1 > start) {
 stack[++top] = (Range){start, pivot_index - 1};
 }
 if (pivot_index + 1 < end) {
 stack[++top] = (Range){pivot_index + 1, end};
 }
 }

 free(stack);
}

int main(void) {
 int arr[] = {29, 17, 45, 12, 53, 7, 84, 65, 96, 41, 71, 88};
 int len = (int)(sizeof(arr) / sizeof(arr[0]));

 quick_sort_iterative(arr, len);
 print_array(arr, len);
 return 0;
}

输出结果：

1

7 12 17 29 41 45 53 65 71 84 88 96

快速排序（递归法）

快速排序的递归版是最常见的写法。
每次分区后，递归处理基准值左边和右边两个子区间。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


#include <stdio.h>

void print_array(const int arr[], int len) {
 for (int i = 0; i < len; i++) {
 printf("%d ", arr[i]);
 }
 printf("\n");
}

int partition(int arr[], int low, int high) {
 int pivot = arr[high];
 int i = low - 1;

 for (int j = low; j < high; j++) {
 if (arr[j] <= pivot) {
 i++;
 int temp = arr[i];
 arr[i] = arr[j];
 arr[j] = temp;
 }
 }

 int temp = arr[i + 1];
 arr[i + 1] = arr[high];
 arr[high] = temp;
 return i + 1;
}

void quick_sort_recursive(int arr[], int low, int high) {
 if (low < high) {
 int pivot_index = partition(arr, low, high);
 quick_sort_recursive(arr, low, pivot_index - 1);
 quick_sort_recursive(arr, pivot_index + 1, high);
 }
}

int main(void) {
 int arr[] = {29, 17, 45, 12, 53, 7, 84, 65, 96, 41, 71, 88};
 int len = (int)(sizeof(arr) / sizeof(arr[0]));

 quick_sort_recursive(arr, 0, len - 1);
 print_array(arr, len);
 return 0;
}

输出结果：

1

7 12 17 29 41 45 53 65 71 84 88 96

看完整篇后，可以把这几种排序分成两类来记：

基础交换/插入类：冒泡、选择、插入、希尔
分治类：归并、快速

这样复习时会更容易抓住主线，而不是把每一段代码都当成独立模板死记。

如何选择排序算法

数据量很小、主要为了练基本功时，可以先从冒泡、选择、插入开始。
数据接近有序时，插入排序往往比你想象中更好用。
需要稳定性并且能接受额外空间时，归并排序是更稳妥的选择。
追求平均性能、接受最坏情况退化风险时，快速排序通常是默认候选。
真实项目里如果标准库已经提供了成熟排序接口，优先用库，再回头理解这些算法思想。

常见错误

冒泡排序和选择排序把内层循环边界写错，导致比较次数不足，或者访问 arr[j + 1] 越界。
插入排序忘了把较大的元素向后移动，只保留了“插入”动作，结果会覆盖原数据。
希尔排序把 gap 缩小逻辑写错，或者没有最终缩到 1，导致数组并没有真正排完。
归并排序没有正确分配辅助数组，或者合并后没有把临时结果拷回原数组。
归并排序的递归终止条件写错，导致递归不收敛或重复处理同一区间。
快速排序分区时把基准值交换顺序写乱，最终会出现重复元素丢失或分区不正确。
快速排序在最坏情况下递归层数很深，如果输入接近有序又总是选边界元素做基准，性能会明显下降。
把函数参数里的数组再次用 sizeof(arr) / sizeof(arr[0]) 求长度，结果得到的是指针大小，不是真实元素个数。

7.2 随机数与简单模拟

Tue, 14 Apr 2026 00:00:00 +0800

随机数与简单模拟

概念说明

在实际编程中，我们经常需要生成随机数，例如掷骰子、随机抽样、洗牌、小游戏事件触发等。在 C 语言里，最常见的入门接口是 <stdlib.h> 中的 rand() 和 srand()。

不过要先建立一个重要认识： rand() 生成的通常不是“真正随机数”，而是伪随机数，也就是由某个初始种子按固定规则推导出来的数列。

这意味着两件事：

给定相同种子，通常会得到相同序列。
如果你从不设置种子，程序每次启动时往往会重复同一条序列。

语法/规则

rand() 会返回一个位于 0 到 RAND_MAX 之间的整数。
srand(seed) 用来设置随机种子，常见写法是 srand((unsigned)time(NULL));。
种子通常只需要在程序启动时设置一次，不要在循环里反复重设。
rand() % n 能快速得到 0 到 n - 1 之间的整数，但会存在一定偏差。
对于入门练习和简单小游戏，rand() 足够用；对于密码学或安全用途，它远远不够。
如果要得到 1 到 6 之间的整数，常见写法是 rand() % 6 + 1。
写随机逻辑时，最好先验证结果是否落在预期范围内，再考虑分布是否均匀。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


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

int main(void) {
 int range_ok = 1;

 srand(1);
 for (int i = 0; i < 100; i++) {
 int dice = rand() % 6 + 1;
 if (dice < 1 || dice > 6) {
 range_ok = 0;
 }
 }

 printf("range_ok = %d\n", range_ok);
 return 0;
}

输出结果：

1

range_ok = 1

这里使用固定种子 1，是为了让示例更稳定。真正做随机模拟时，通常会改成基于时间的种子。

常见错误

每次生成随机数前都调用一次 srand，结果让序列反而变得更差。
忘记设置种子，导致程序每次启动都得到相同的随机序列。
以为 rand() 适合做密码、令牌或安全随机用途，实际上它并不适合。
只会写 rand() % n，却没意识到这种映射在严格场景下可能有偏差。
只关注“看起来随机”，却没有先验证结果是否满足基本范围约束。

7.3 调试基础与断言

Tue, 14 Apr 2026 00:00:00 +0800

调试基础与断言

概念说明

调试不是“程序写完以后才做的补救动作”，而是理解程序真实执行过程的重要手段。当代码开始涉及数组、指针、函数调用和文件读写时，只靠肉眼读源码往往已经不够了。

最常见的调试手段可以分成三类：

调试器：断点、单步执行、查看变量、观察调用栈。
断言：在关键位置检查程序内部假设是否成立。
调试输出：临时打印路径、参数和中间结果，帮助定位问题范围。

调试的目标不是“盲猜哪里错了”，而是缩小问题范围。先确认程序走到了哪一步，再确认关键变量是什么值，最后再确认它为什么变成这样。

语法/规则

调试构建通常建议保留符号信息，例如使用 -g，必要时降低优化级别，例如 -O0。
断点适合回答“程序到底有没有走到这里”。
单步进入、单步跳过和单步跳出适合观察函数调用过程和局部变量变化。
观察窗口或监视表达式适合持续跟踪某个变量在循环和函数中的变化。
assert 用来检查程序内部不应该被破坏的假设，而不是用来替代用户输入校验。
定义 NDEBUG 后，assert 通常会被禁用，因此不能把业务必需的运行时检查全放进断言里。
调试输出要尽量有上下文，例如输出变量名、阶段名和关键索引，而不是只打印一个孤立数字。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


#include <assert.h>
#include <stdio.h>

#define DEBUG 1

#if DEBUG
#define DBG_PRINT(fmt, ...) fprintf(stderr, "[DEBUG] " fmt "\n", __VA_ARGS__)
#else
#define DBG_PRINT(fmt, ...)
#endif

int sum_positive(const int arr[], int len) {
 assert(arr != NULL);
 assert(len >= 0);

 int sum = 0;
 for (int i = 0; i < len; i++) {
 DBG_PRINT("i=%d value=%d", i, arr[i]);
 if (arr[i] > 0) {
 sum += arr[i];
 }
 }
 return sum;
}

int main(void) {
 int nums[] = {3, -1, 5};
 printf("sum = %d\n", sum_positive(nums, 3));
 return 0;
}

输出结果：

1
2
3
4


[DEBUG] i=0 value=3
[DEBUG] i=1 value=-1
[DEBUG] i=2 value=5
sum = 8

这个例子里，assert 负责检查函数前提条件，DBG_PRINT 负责把循环过程可视化。两者搭配起来，排查逻辑错误会比只看最终结果轻松很多。

常见错误

一发现结果不对就盲改代码，却没有先确认程序到底走到了哪里。
把 assert 当成用户输入校验的唯一手段，结果发布构建中断言被关闭后失去保护。
调试输出只打印一个数字，没有变量名、索引或阶段信息，导致信息价值很低。
调试时只看当前行，不看调用栈和前后状态变化，结果总在表面现象里打转。
排完问题以后忘记清理临时调试代码，导致正式输出被调试信息污染。