C语言语句本质：执行单元与控制流的底层逻辑

C语言语句控制语句

于 2026-10-02 07:36:10 修改

·本内容遵循CC 4.0 BY-SA版权协议

1. 这不是语法清单，而是一张C语言执行逻辑的“交通指挥图”

你打开任何一本C语言教材，翻到“语句”这一章，大概率会看到一张干巴巴的分类表：表达式语句、函数调用语句、空语句、复合语句……然后就是一堆带分号的代码片段。我带过几十期C语言实训班，几乎每届都有学员在学完“if-else”后，写出来的程序逻辑像一锅乱炖——明明条件成立，却执行了else分支；循环里变量该加没加，跑着跑着就卡死；函数调用后程序直接跳过后续代码，连调试器都找不到断点在哪。问题出在哪？不是他们没背熟语句类型，而是根本没搞懂：C语言里的每一条语句，本质上都是CPU执行路径上的一个路标、一个开关、一个闸门。它不只告诉你“怎么写”，更决定着“程序往哪走、停在哪、跳到哪”。今天这篇，我就把这张“交通指挥图”摊开来讲透。不列教科书定义，不堆代码块，只讲你写代码时真正要面对的决策点、陷阱点和实操心法。核心关键词——C、语句、控制语句、函数调用语句、表达式语句——全都会落在具体场景里，比如你写一个温度监控程序，为什么if (temp > 30)后面必须跟一个分号或一个复合语句块？为什么printf("OK");和printf("OK")（少个分号）编译结果天差地别？为什么return;在void函数里是合法语句，而在int函数里就是致命错误？这些，才是你每天敲键盘时真正在和编译器博弈的东西。适合刚学完变量和运算符、正准备啃流程控制的新手，也适合写了两年代码但总在调试时抓耳挠腮的老手——因为很多坑，根源就在对“语句”这个最基础概念的理解偏差上。

2. 语句的本质：从“一行代码”到“执行指令流”的认知跃迁

2.1 语句不是“句子”，而是“执行单元”：编译器视角下的真实含义

很多人初学时有个根深蒂固的误解：语句 = 一行代码。看到x = y + z;，觉得这就是一条“赋值语句”；看到printf("Hello");，觉得这就是一条“输出语句”。这种理解在简单例子里不会出错，但一旦进入复杂逻辑，立刻崩盘。真相是：C语言中的“语句”，是编译器将源代码翻译成机器指令时，划分执行单元的最小边界。它决定了控制流（CPU下一步执行哪里）的切换点、作用域（变量在哪儿能被访问）的起止线、以及资源（栈空间、寄存器）的分配与释放时机。

举个最典型的例子：if (x > 0) y = 1; else y = -1;。表面看是三条语句，但编译器眼里，这是一个完整的“选择语句”（selection statement），它生成的汇编指令可能只有几条：比较x和0、根据标志位跳转、加载1或-1到y的内存地址。y = 1;和y = -1;这两条“表达式语句”，在这里完全失去了独立性，它们的执行与否，由if这个控制语句的判断结果绝对支配。如果你把if后面的分号误写成if (x > 0); y = 1; else y = -1;，编译器会报错，因为else前面已经没有匹配的if了——那个分号，把if (x > 0);变成了一个独立的、什么也不做的“空语句”，y = 1;成了无条件执行的下一条语句，else彻底孤立。这根本不是语法错误，而是执行单元边界被错误切割导致的逻辑坍塌。

再看函数调用：result = calculate(a, b);。这里calculate(a, b)是一个表达式，result = ...是赋值操作，整个result = calculate(a, b);才构成一条“表达式语句”。但它的执行过程远比表面复杂：先压入参数a、b到栈（或寄存器），跳转到calculate函数入口，执行函数体内的所有语句，遇到return语句时，把返回值存入特定寄存器（如EAX），然后跳回result = ...这条语句的下一条指令，并把寄存器里的值赋给result。整个过程，calculate(a, b)这个表达式，是嵌套在更大执行单元（赋值语句）内部的一个子执行单元。理解这一点，你就明白为什么printf("Value: %d", x);里，x的值是在printf函数内部被读取并格式化的，而不是在printf调用前就被“计算好”塞进去的——执行单元的嵌套关系，决定了求值时机。

提示：当你在VSCode里按F5调试，看到黄色箭头停在某一行，那一行代表的不是一个“代码行”，而是一个“可中断的执行单元起点”。如果箭头停在for (i=0; i<10; i++) { ... }这行，它停的是整个for循环的入口，不是括号里的某个部分。理解语句作为执行单元，是读懂调试器行为的第一步。

2.2 五类语句的底层逻辑：为什么这样分类？它们解决什么根本问题？

C标准（ISO/IEC 9899）将语句分为五大类，这个分类不是拍脑袋定的，而是严格对应CPU执行模型的五个核心需求：

表达式语句（Expression Statement）：解决“执行一个计算并丢弃结果”的需求。绝大多数赋值、函数调用、自增自减都属于此类。核心特征：以表达式结尾，加分号。x++; func(); a = b * c;。它的存在，让程序员能明确告诉编译器：“我要执行这个动作，但不需要它的返回值（或返回值无关紧要）”。比如fclose(fp);，我们关心的是文件是否成功关闭，fclose的返回值（-1表示失败）常被忽略，所以它天然就是一条表达式语句。
复合语句（Compound Statement / Block）：解决“把多条语句打包成一个逻辑单元”的需求。用花括号{}包裹。这是C语言实现“作用域”和“逻辑分组”的唯一机制。if (cond) { a=1; b=2; }里的{ a=1; b=2; }就是一个复合语句，它让a和b的声明（如果有的话）只在花括号内有效，也让if能控制两条语句的执行。没有复合语句，C语言就无法实现任何有意义的结构化编程。
控制语句（Control Statements）：解决“改变默认执行顺序（从上到下）”的需求。包括if-else、switch、while、do-while、for、break、continue、goto、return。它们是程序拥有“智能”的基石。if是条件分支的开关，for是循环的计数器与控制器，return是函数执行的出口闸门。它们共同构成了程序的“骨架”。
跳转语句（Jump Statements）：break、continue、goto、return。注意，return既是控制语句也是跳转语句，因为它不仅结束当前函数（控制流），还强制跳转回调用点（跳转）。这类语句的核心价值是“打破线性”，提供快速退出或重定向的能力。break跳出最近的switch或循环，continue跳过本次循环剩余部分直接进入下一次判断，goto则提供无条件跳转（虽不推荐，但在处理多重嵌套错误清理时有其不可替代性）。
空语句（Null Statement）：解决“语法上需要一条语句，但逻辑上什么都不做”的需求。就是单独一个分号;。它看似无用，实则关键。while (getchar() != '\n'); 这个经典用法，就是利用空语句作为while的循环体，目的只是不断读取字符直到换行符，不执行任何其他操作。没有空语句，这种简洁的“忙等待”写法就无法实现。

这五类，覆盖了从最简单的动作执行（表达式语句），到最复杂的流程调度（控制语句）的所有层面。它们不是并列的“种类”，而是层层递进的“能力封装”：表达式语句是砖块，复合语句是砌墙，控制语句是设计房屋结构，跳转语句是安装门窗，空语句则是预留的通风口。理解这个层级关系，比死记硬背分类重要十倍。

2.3 “语句”与“表达式”的生死线：分号，那个被严重低估的终结符

C语言里，分号;不是句号，它是执行单元的封印。它标志着一个独立的、可被编译器单独处理的指令序列的结束。这个认知偏差，是新手踩坑的头号原因。

表达式 vs 表达式语句：x + y是一个表达式，它计算x和y的和，但这个值如果不被使用（赋值、传参、作为条件），就完全被丢弃，且不产生任何副作用（不改变任何变量）。x + y;则是一条表达式语句，它强制执行了x+y的计算，并明确告诉编译器：“执行完这个计算，然后停下来，准备执行下一条语句”。虽然结果仍被丢弃，但“执行”这个动作本身已被确认。
函数声明 vs 函数调用：int func(int a);是函数声明，是告诉编译器“有这么个函数，它长这样”，这不是语句，是声明，不产生执行代码。func(5);是函数调用表达式，加上分号func(5);，才成为一条表达式语句，才会真的去调用那个函数。
最致命的陷阱：if/for/while后面的分号：

C

if (x > 0); // 错！这里分号创建了一个空语句，if的“真分支”永远为空

printf("x is positive!\n"); // 这行代码永远执行，和if无关！

编译器看到if (x > 0);，认为这是一个完整的、合法的“if语句”，其真分支就是那个空语句。printf是下一条独立的语句，不受if控制。修复方法？删掉分号，或者用复合语句：if (x > 0) { printf("x is positive!\n"); }。

这个分号，就是C语言语法的“奇点”。它微小，却决定了代码的生死。我见过太多人，在VSCode里配置好C/C++环境，写完代码按Ctrl+Shift+B编译通过，运行结果却完全不对，最后发现就是多打了一个分号。它不报错，只默默扭曲你的逻辑。记住：分号是语句的句点，不是代码行的句号。写完一个逻辑单元，再考虑加不加分号。

3. 核心语句类型深度拆解：原理、陷阱与实操心法

3.1 表达式语句：被当作“万能胶水”，实则暗藏玄机

表达式语句是C语言里最常见、也最容易被轻视的语句类型。a = 5;, i++;, printf("Hello");，看起来简单粗暴。但正是这种“简单”，让它成了bug的温床。它的核心在于：一个表达式 + 一个分号 = 一个具有明确副作用的执行单元。

原理再探：表达式本身有“值”和“副作用”。x = 5的值是5，副作用是把5存入x的内存地址；i++的值是i的旧值，副作用是把i加1；printf(...)的值是打印的字符数，副作用是向stdout输出内容。表达式语句，就是要求编译器必须执行这个表达式的副作用，并丢弃其值（除非这个值被用于更大的上下文，比如y = (x = 5);中，x=5的值被赋给了y）。

实操陷阱与心法：

赋值与相等的混淆（= vs ==）：这是C语言头号经典错误。

C

if (x = 5) { ... } // 错！这是赋值语句，x被设为5，表达式值为5（非零），条件恒真！

if (x == 5) { ... } // 对！这是相等比较，返回真或假。

心法：在条件判断中，把常量放左边，形成if (5 == x)。如果误写成if (5 = x)，编译器会直接报错“lvalue required”，因为5不能被赋值。这是一种防御性编程技巧。
逗号表达式的“伪复合”陷阱：a = 1, b = 2, c = 3; 是一条表达式语句，但它由三个表达式用逗号连接而成。逗号表达式的规则是：从左到右依次求值，整个表达式的值是最后一个表达式的值。所以这条语句等价于c = 3;，a和b的赋值是副作用，但a和b的值在语句结束后是确定的。然而，如果写成if (a = 1, b = 2, c = 3) { ... }，条件判断的是c=3的值（3），而非a、b、c是否都非零。这很容易误导人以为是在做“多重条件检查”。
函数调用语句的“黑洞”特性：scanf("%d", &x); 是一条表达式语句。scanf的返回值是成功读取的项数。如果用户输入了非数字字符，scanf会失败，返回0，但x的值保持不变（未定义）。很多新手只关注x，却忽略了scanf的返回值，导致程序在非法输入后行为不可预测。心法：对于关键输入，务必检查返回值：

C

if (scanf("%d", &x) != 1) {

fprintf(stderr, "Invalid input!\n");

exit(EXIT_FAILURE);

}
自增/自减的“前置”与“后置”之辨：i++和++i都是表达式语句，但值不同。i++的值是i的旧值，++i的值是i的新值。在独立语句中（i++;），两者效果完全一样。但在表达式中（a = i++; vs a = ++i;），结果天壤之别。心法：如果只需要改变i的值，用i++或++i都可以；如果需要利用其返回值，务必想清楚你需要的是旧值还是新值。

注意：在VSCode配置C/C++环境时，启用-Wall（所有警告）和-Wextra（额外警告）编译选项，编译器会帮你揪出很多表达式语句的潜在问题，比如未使用的返回值（scanf）、赋值作条件（if (x = 5)）等。这是比肉眼检查分号更可靠的防线。

3.2 控制语句：程序的“神经中枢”，如何避免逻辑瘫痪

控制语句是C语言的灵魂，它们决定了程序的“思考路径”。if-else是二选一的开关，switch是多路选择器，while和for是循环引擎。但它们的威力越大，误用的风险越高。核心原则：控制语句的“身体”（条件、循环变量）和“灵魂”（执行体）必须严丝合缝，否则整个逻辑链就会断裂。

if-else的“悬空else”与作用域迷雾：

if (x > 0)

if (y > 0)

printf("Both positive\n");

else

printf("x is not positive\n");

这段代码的本意可能是：如果x>0且y>0，打印A；否则，如果x<=0，打印B。但C语言的语法规则规定：else总是与离它最近的、尚未配对的if配对。所以这里的else，实际上配对的是if (y > 0)，而不是if (x > 0)。这意味着，当x>0但y<=0时，什么都不会打印。这是经典的“悬空else”（dangling else）问题。

心法：永远用花括号{}显式界定if和else的执行体，无论里面只有一条语句还是多条。这是业界公认的黄金法则，能彻底杜绝悬空else，并清晰定义作用域。

if (x > 0) {

if (y > 0) {

printf("Both positive\n");

}

} else {

printf("x is not positive\n");

}

switch的“贯穿”（fall-through）与default的隐形守护：

switch (grade) {

case 'A':

printf("Excellent\n");

case 'B':

printf("Good\n");

case 'C':

printf("Average\n");

default:

printf("Unknown grade\n");

}

如果grade是'A'，程序会依次打印"Excellent"、"Good"、"Average"、"Unknown grade"。因为case标签后如果没有break，程序会“贯穿”到下一个case，直到遇到break或switch结束。这并非bug，而是C语言的设计特性，有时用于实现“范围匹配”（如case 1: case 2: case 3:），但绝大多数时候是疏忽。

心法：

每个case分支的末尾，除非你明确需要贯穿，否则必须写break;。
default分支必须存在，即使它只是default: break;。它处理所有未被case覆盖的情况，是程序健壮性的最后一道保险。在嵌入式开发中，遗漏default可能导致未定义行为，引发严重事故。

for循环的“三要素”与无限循环的温柔陷阱： for (init; condition; increment) { body; } 的三要素缺一不可，但它们的执行时机有严格顺序：

执行init（仅一次）
检查condition，若为真，执行body
执行increment
跳回第2步

最常见的陷阱是把increment写在body里，却忘了在for的第三部分写，导致无限循环：

for (i = 0; i < 10; ) { // 错！缺少increment

printf("%d ", i);

i++; // 这里写了，但逻辑上容易遗漏

}

心法：把for循环看作一个“自动化的while”。上面的for等价于：

i = 0;

while (i < 10) {

printf("%d ", i);

i++; // increment必须在这里，且不能遗漏

}

如果逻辑复杂，优先用while，它更直观；如果逻辑简单、边界清晰，for更简洁。不要为了用for而用for。

3.3 复合语句与空语句：看不见的“结构工程师”

复合语句{}和空语句;，一个像钢筋，一个像空气，它们不直接做计算，却支撑着整个程序的结构。忽视它们，就像盖楼不打地基。

复合语句：作用域的“结界”与初始化的“安全屋”：

{

int temp = x * y; // temp只在这个复合语句内有效

result = temp + z;

} // temp在此处销毁，内存被回收

// printf("%d", temp); // 错！temp在此处已不存在

复合语句创造了新的作用域。在这个作用域内声明的变量，生命周期仅限于此。这不仅是内存管理的需要，更是逻辑隔离的利器。在大型函数中，用复合语句把相关操作分组，可以极大提升代码可读性：

// 计算用户积分

{

int base_score = get_base_score(user_id);

int bonus = calculate_bonus(user_id, base_score);

user_points = base_score + bonus;

}

// 发送通知

{

char notification[256];

snprintf(notification, sizeof(notification), "Your points: %d", user_points);

send_notification(user_id, notification);

}

两个{}块互不干扰，变量名可以重复（如都叫score），逻辑清晰。这是C语言实现“局部性”和“高内聚”的核心手段。

空语句：最简练的“占位符”与最危险的“沉默杀手”：空语句;的用途极其有限，但每个都至关重要：

while循环的“忙等待”：while (flag == 0); 等待flag变为非零。
for循环的“无操作初始化/增量”：for (p = head; p != NULL && p->data != target; p = p->next); 在循环条件里完成遍历，循环体为空。
if的“条件满足即退出”：if (error) return -1; 后面不需要else，直接写后续代码。

但它的危险性在于“无声无息”。if (x > 0); { printf("x is positive"); } 这段代码，printf永远不会执行，因为if后面那个分号，已经是一个完整的空语句，printf所在的复合语句，是if之外的独立语句。心法：在VSCode里，开启“显示空白字符”功能（Ctrl+Shift+P -> Toggle Render Whitespace），让分号和空格无所遁形。一个孤零零的;，就是潜在的逻辑断点。

4. 实操全景：从零构建一个“温度监控系统”的语句应用

现在，让我们把所有理论，放进一个真实的、可运行的小项目里：一个模拟的“温度监控系统”。它会读取传感器数据，根据阈值发出不同级别的警报，并记录日志。这个项目会密集使用所有类型的语句，让你看到它们是如何协同工作的。

4.1 需求与架构：语句是功能的“施工蓝图”

系统需求：

模拟读取温度值（0-100摄氏度）。
温度 > 80°C：触发“高温警报”，发送紧急通知，记录ERROR日志。
温度 > 60°C 且 <= 80°C：触发“预警”，发送普通通知，记录WARNING日志。
温度 <= 60°C：一切正常，记录INFO日志。
系统持续运行，每5秒读取一次。

架构设计（语句视角）：

数据获取：用表达式语句调用模拟函数read_sensor()。
核心决策：用if-else if-else控制语句链进行多级判断。
动作执行：每个分支内，用表达式语句调用send_alert()和log_message()。
循环控制：用while(1)无限循环，配合sleep(5)实现间隔。
错误处理：在关键函数调用后，用if检查返回值，用return或break跳转。

4.2 完整代码与逐行语句解析

# include <stdio.h>

# include <stdlib.h>

# include <time.h>

# include <unistd.h> // for sleep()

// 模拟传感器读取函数：返回0-100的随机温度

int read_sensor(void) {

return rand() % 101; // 表达式语句：计算并返回随机数

}

// 模拟发送警报：0成功，-1失败

int send_alert(const char* level, const char* message) {

printf("[ALERT %s] %s\n", level, message); // 表达式语句：调用printf

return 0; // 表达式语句：返回0

}

// 模拟记录日志

void log_message(const char* level, const char* message) {

printf("[LOG %s] %s\n", level, message); // 表达式语句：调用printf

}

int main(void) {

srand(time(NULL)); // 表达式语句：初始化随机数种子

while (1) { // 控制语句：无限循环的入口

int temperature = read_sensor(); // 表达式语句：调用函数并赋值

printf("Current temperature: %d°C\n", temperature); // 表达式语句：输出当前值

// 核心控制语句链：多级if-else if-else

if (temperature > 80) { // 控制语句：条件判断

// 复合语句：高温警报分支

if (send_alert("CRITICAL", "Temperature exceeds 80°C!") != 0) { // 控制语句嵌套

fprintf(stderr, "Failed to send critical alert!\n"); // 表达式语句

break; // 跳转语句：跳出while循环

}

log_message("ERROR", "Critical temperature detected."); // 表达式语句

} else if (temperature > 60) { // 控制语句：else if是if-else的语法糖

// 复合语句：预警分支

send_alert("WARNING", "Temperature is high (60-80°C)."); // 表达式语句

log_message("WARNING", "High temperature warning issued."); // 表达式语句

} else { // 控制语句：最终的else分支

// 复合语句：正常状态分支

log_message("INFO", "Temperature is normal."); // 表达式语句

}

sleep(5); // 表达式语句：暂停5秒

} // while循环结束

return 0; // 跳转语句：main函数返回，程序结束

}

关键语句点解析：

srand(time(NULL));：这是一个表达式语句，但它的副作用（初始化随机数种子）对后续所有rand()调用至关重要。如果漏掉，read_sensor()每次都会返回相同的“随机”数。
while (1) { ... }：1是一个永真的表达式，while将其作为条件。这是一个标准的无限循环模式，比for (;;)更易读。
int temperature = read_sensor();：这是声明+初始化+函数调用的复合表达式语句。temperature的作用域仅限于main函数，这是复合语句（函数体）提供的作用域。
if (temperature > 80) { ... } else if (...) { ... } else { ... }：这是一个完整的控制语句链。每个{ ... }都是一个复合语句，确保了分支内多条语句的逻辑绑定。else if不是独立语句，而是else后面紧跟一个if语句的简写。
if (send_alert(...) != 0) { ... }：这是控制语句的嵌套。外层if判断温度，内层if判断警报发送是否成功。send_alert的返回值被显式检查，体现了对函数调用语句副作用的重视。
break;：在send_alert失败时，break跳转语句直接跳出最外层的while循环，终止程序。这是break最典型的用法：异常情况下的快速退出。
return 0;：这是main函数的结束语句。它既是控制语句（结束函数），也是跳转语句（跳转回操作系统）。0表示程序成功退出，这是POSIX标准。

4.3 VSCode配置与调试实战：让语句“活”起来

要在VSCode里高效开发和调试这个程序，正确的配置是前提。这不仅仅是“让代码跑起来”，更是让你能看清每一条语句的执行轨迹。

安装必要插件：C/C++（Microsoft官方）、CMake Tools（如果用CMake）、Code Runner（快速运行单文件）。
配置tasks.json（编译任务）：

JSON

{

"version": "2.0.0",

"tasks": [

{

"type": "cppbuild",

"label": "C/C++: gcc build active file",

"command": "/usr/bin/gcc", // Linux/macOS路径，Windows用gcc.exe

"args": [

"-g", // 生成调试信息

"-Wall", // 所有警告

"-Wextra", // 额外警告

"-std=c11", // 使用C11标准

"${file}",

"-o",

"${fileDirname}/${fileBasenameNoExtension}"

],

"options": {

"cwd": "${fileDirname}"

},

"problemMatcher": ["$gcc"],

"group": "build",

"detail": "Task generated by Debugger."

}

]

}

关键参数：-Wall -Wextra会捕获if (x=5)、未使用变量、未初始化变量等语句级错误；-g是调试的必需品。
配置launch.json（调试配置）：

JSON

{

"version": "0.2.0",

"configurations": [

{

"name": "C Launch",

"type": "cppdbg",

"request": "launch",

"program": "${fileDirname}/${fileBasenameNoExtension}",

"args": [],

"stopAtEntry": false,

"cwd": "${fileDirname}",

"environment": [],

"externalConsole": true,

"MIMode": "gdb",

"setupCommands": [

{

"description": "Enable pretty printing for gdb",

"text": "-enable-pretty-printing",

"ignoreFailures": true

}

],

"preLaunchTask": "C/C++: gcc build active file"

}

]

}

externalConsole: true很重要，因为我们的程序需要printf输出到终端，而不是VSCode的集成终端（后者对sleep支持不好）。
调试心法：
- 在int temperature = read_sensor();这行设断点，F5启动，程序会在读取温度后暂停。观察temperature变量的值。
- 按F10（Step Over），执行下一条语句printf("Current temperature...")，看输出是否正确。
- 按F11（Step Into），如果光标停在read_sensor()上，会进入函数内部，看到rand() % 101这条表达式语句是如何执行的。
- 在if (temperature > 80)这行设断点，修改temperature的值（在调试面板里右键变量->"Set Value"），分别设为85、70、50，观察程序如何精确地跳入不同的if、else if、else分支。这就是控制语句在你眼前“呼吸”的时刻。

5. 常见问题与排查技巧实录：那些年我们一起踩过的语句坑

在C语言教学和工程实践中，有些关于语句的问题，出现频率高得惊人，几乎成了“职业病”。下面是我整理的“语句问题速查表”，附带真实排查过程和独家心法。

5.1 经典问题速查表

问题现象	可能原因	排查步骤	解决方案	我的实操心得
程序编译通过，但运行结果完全不对，或崩溃	`if`、`for`、`while`后面多了一个分号，导致执行体被剥离	1. 用VSCode的“显示空白字符”功能，检查所有控制语句后是否有孤立的`;`。 2. 在疑似出错的`if`或`for`行设断点，单步执行，观察黄色箭头是否跳过了你认为该执行的代码块。	删除多余的分号。牢记：`if (cond);` 是一个完整的、空的`if`语句。	我带的第一个班，有7个人同时栽在这个坑里。后来我发明了一个“分号红绿灯”规则：写完`if`、`for`、`while`，立刻问自己“这里需要一个分号吗？”，答案永远是“否”，除非你明确想写一个空语句。
`switch`语句中，多个`case`的代码被连续执行	`case`分支末尾缺少`break;`，发生了“贯穿”	1. 检查每一个`case`标签后的代码，确认是否都有`break;`。 2. 如果确实需要贯穿（如`case 1: case 2: case 3:`），在代码上方加注释`/* fall through */`，提醒自己和他人。	为每个`case`添加`break;`。对`default`分支也强制添加`break;`。	在嵌入式项目里，一个遗漏的`break`曾导致电机驱动器在特定条件下持续加速，差点撞墙。从此，我的代码审查清单第一条就是“`switch`的`break`”。
变量在`if`或`for`的复合语句`{}`内声明，但在外面无法访问	C89标准不支持在`for`循环内声明变量（`for (int i=0; ...)`），或变量作用域理解错误	1. 检查编译器标准（`-std=c99`或`-std=c11`）。 2. 确认变量声明的位置：在`{}`内声明，作用域仅限