C语言逻辑量与分支语句：从逻辑运算符到if/switch实战解析

1. 内容整体设计与思路拆解

1.1 这个项目标题到底在说什么

"C语言 逻辑量、逻辑运算符和逻辑表达式、if语句和switch语句"——这个标题放在一起看，其实覆盖的是C语言里"从判断到分支"的完整链条。很多初学者一上来就把逻辑运算符当成数学里的"与或非"，又把if和switch当作两个孤立的关键字去背语法，结果一到写实际程序就乱：要么优先级算错，要么switch忘写break导致穿透，要么该用if的地方用了switch，代码绕了一大圈还跑不对。

我这些年带过不少入门的人，也帮别人调试过很多C语言程序，发现一个规律：凡是条件分支这块基础不牢的，后面学循环、学函数、学指针都会别别扭扭。原因很简单，C语言程序的执行是靠"顺序 + 分支 + 循环"三种结构撑起来的，而分支结构的地基就是逻辑量和逻辑表达式。地基不牢，上层全是裂缝。

这篇内容就是围绕标题里的六个核心概念展开的，目的是把"怎么判断真与假"到"怎么根据真假选择执行路线"这根线彻底捋顺。我尽量不堆砌教科书式定义，而是把每一个运算符、每一种语法背后的行为和常见坑都讲清楚，配上可以直接抄走的代码片段。

1.2 为什么逻辑量是C语言里最容易被低估的概念

先说一个很多人没意识到的问题：C语言其实没有真正的布尔类型（C99之后引入了_Bool，但那是后话），它用整数表示真假。规则非常简单粗暴——0代表假，非0代表真。这个"非0即真"的规则是整个逻辑体系的地基。

打个比方，你晚上回家开门，门锁判断"钥匙对不对"，在C语言的世界里，1、2、-3、100统统都算"钥匙对"，只有0算"钥匙不对"。这种设计的好处是写起来极其自由，坏处就是新手经常写出"判断一个数是否等于5，结果判断成了if (x = 5)"这种经典事故。

逻辑量这个词，说的就是"具有真假属性"的量。具体到C语言里，任何能产生0或非0整数结果的表达式，都可以充当逻辑量。这意味着：关系表达式的结果是逻辑量，逻辑表达式的结果是逻辑量，甚至一个普通的整数变量本身也可以直接当逻辑量用。灵活是真的灵活，但如果你不懂背后的判定规则，写出来的代码就跟碰运气一样。

1.3 我把整条知识链拆成了什么样的结构

考虑到标题本身已经把知识点列出来了，我决定按"基础规则 → 运算符细节 → 表达式写法 → 分支语句 → 实战对比"这条顺序来讲。逻辑量是地基，逻辑运算符是工具，逻辑表达式是组合方式，if和switch是最终的应用出口。前四节环环相扣，最后一节用来解决"到底该用if还是switch"这个实际编程里绕不开的问题。

这种安排是为了让不同基础的人都能找到适合自己的阅读节奏。你要是完全零基础，就从头往后看，每一步我都尽量讲透；你要是已经会一点C语言，可以直接跳到第4节和第5节，里面有很多平时不容易注意到的细节和坑。我尽量用实际编程里经常遇到的场景来解释每一个知识点，而不是给出干巴巴的语法定义。

2. 核心基础概念拆解：三大逻辑运算符

2.1 三种逻辑运算符的规则与真值表

C语言里有三种逻辑运算符，分别是逻辑与&&、逻辑或||、逻辑非!。它们处理的对象是"条件"，输出的结果是整数0或1。这里的0就是"假"，1就是"真"。

• 逻辑与&&：左右两个操作数都为真时，结果才为真。只要有一个为假，结果就是假。
• 逻辑或||：左右两个操作数只要有一个为真，结果就为真。只有当两个都为假时，结果才是假。
• 逻辑非!：单目运算符，把真变成假，把假变成真。

把这三种规则的完整真值表列出来是这样：

注意，这里的"非0"包含了所有负数。很多初学者想当然地认为"负数应该算假"，这完全是误解。C语言从来没说过"正数才是真"，它只认0和非0。比如-1这个值，逻辑上就是真，if (-1)一定会走进分支。

2.2 短路求值：C语言最实用的特性之一

逻辑与和逻辑或有一个非常重要的特性，叫做"短路求值"。简单说，就是一旦结果已经确定，就不再计算剩余部分。

• a && b：如果a为假，那么不管b是真还是假，a && b的结果已经确定为假，所以b根本不会被计算。
• a || b：如果a为真，那么不管b是真还是假，a || b的结果已经确定为真，所以b同样不会被计算。

这个特性在实际工程里用处极大。最经典的就是指针判空：

if (ptr != NULL && ptr->value > 10) { // 安全：ptr为空时，后面的ptr->value根本不会执行 }

如果C语言没有短路求值，上面这段代码在ptr == NULL时仍然会去访问ptr->value，直接引起段错误崩溃。正是因为有短路机制，ptr != NULL一旦不成立，后面的访问就被跳过了，程序才能安全运行。

再举一个日常场景：从键盘读取字符并判断是否为数字，你可能会想用getchar()配合逻辑判断。如果不了解短路机制，就可能写出顺序颠倒的条件，导致先执行了不该执行的操作。这也是我在实际调试中经常看到的低级错误之一。

2.3 运算符优先级：谁先算，谁后算

优先级是逻辑运算里最容易翻车的点。!的优先级最高，其次是算术运算符、关系运算符，再然后是逻辑与&&，接着是逻辑或||，最后是赋值运算符。我直接给出一个简化的优先级表：

实际写代码时，判断一个年份是否为闰年，很多人喜欢加一堆括号，本质上就是因为优先级容易记混。我见过最搞笑的一段写法是：

if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)

这个表达式正确性其实没问题，因为&&优先级高于||，所以它先计算year % 4 == 0 && year % 100 != 0，再跟year % 400 == 0做逻辑或。但说实话，这种写法可读性很差，读代码的人要停下来回忆优先级才能确认逻辑。工程上更推荐显式加括号：

if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))

这样别人一眼就能看出意图，不用猜。

2.4 与位运算符的区分：别把逻辑与和按位与搞混

新手到后面学到位运算符&、|、^的时候，经常把逻辑运算符和位运算符混为一谈。这里必须明确区分：

• 逻辑运算符&&、||的操作对象是"条件"，操作数的任何非0值都视为真，结果只有0或1。
• 位运算符&、|的操作对象是"二进制位"，对操作数的每一位分别计算，结果是一个整数，不是简单的0或1。

举例来说，3 && 2，因为3和2都不是0，都视为真，所以结果是1。但3 & 2，3的二进制是11，2的二进制是10，按位与的结果是10，也就是十进制的2。

这两者的使用场景完全不同。位运算常用来操作寄存器、做标志位的掩码处理，这在实际开发中很常见，但那是另一个话题。在这一阶段，你只需要记住：判断条件用&&和||，处理二进制位用&和|，别混。一旦混了，程序几乎必然出错，而且这种错误往往很难一眼看出来。

3. 逻辑表达式的写法与实战技巧

3.1 关系表达式是逻辑表达式的基石

一个最简单的逻辑表达式，通常是"关系表达式 + 逻辑运算符 + 关系表达式"的形式。关系表达式由关系运算符连接两个操作数组成，比如score >= 60、age < 18、x == 0。关系运算符包括六种：>、<、>=、<=、==、!=。它们的结果是逻辑量，即0或1。

这里有个基础但重要的坑：比较两个浮点数是否相等时，直接用==往往不靠谱。因为浮点数在内存里是近似表示的，0.1 + 0.2 == 0.3在C语言里结果是假，这导致很多初学者一脸懵。正确的做法是判断它们差的绝对值小于某个很小的阈值，比如：

#include <math.h> double a = 0.1 + 0.2; double b = 0.3; if (fabs(a - b) < 1e-9) { // 认为a和b相等 }

在嵌入式开发、科学计算领域，这个细节几乎每天都能遇到。如果你写的是单片机程序，对浮点数做==比较更是大忌，因为目标芯片的浮点运算精度差异会让这种比较变得更玄学。

3.2 复合逻辑表达式的构建技巧

构建复合逻辑表达式时，难点不在于运算符本身，而在于如何把人的语言转换成逻辑表达式。比如"成绩在80到90之间（含80和90）"，初学者普遍喜欢写成80 <= score <= 90，这在C语言里是完全错误的。因为80 <= score的结果是0或1，然后用这个0或1去和90比较，得到的结果和你的预期差了十万八千里。正确写法是：

if (score >= 80 && score <= 90) { // 成绩在区间内 }

再比如"用户名等于admin且密码等于123456"，有人会写username == "admin" && password == "123456"。这个写法的逻辑层面没问题，但字符串比较不能用==，得用strcmp函数。我见过无数新手在这里踩坑，写出来的代码虽然能编译，但运行结果永远不对。正确的写法是：

if (strcmp(username, "admin") == 0 && strcmp(password, "123456") == 0) { // 登录成功 }

3.3 逻辑表达式求值过程中的常见误区

先说赋值与相等的混淆。这是C语言初学者犯得最多的错误，没有之一。if (x = 5)和if (x == 5)看起来只差一个等号，但前者是把5赋给x，然后判断5这个值是否为真，永远为真；后者才是判断x是否等于5。很多编译器的警告选项都能检测到这个错误，我建议你编译时习惯性开启-Wall，让编译器帮你把这类低级问题拦下来。

再来说!运算符使用习惯上的一个坑。!的优先级较高，所以!x == 0实际被解析成(!x) == 0，而不是!(x == 0)。依赖这种写法会让你和你的同事都头大。如果要判断"x不等于0"，直接写if (x != 0)；如果要判断"x等于0"，直接写if (x == 0)，不要绕弯子用!x去表达。

还有一个常见的认知偏差是关于逻辑量结果的用途。逻辑表达式的结果只有0或1，这意味着它可以直接参与算术运算。比如count += (score >= 60);，这条语句在分数及格时给count加1，不及格时加0，可以实现简单的统计功能。虽然这种写法很精巧，但可读性差，除非是在追求极致简洁的场合，否则不推荐。代码首先是给人看的。

3.4 三目运算符与逻辑表达式的血缘关系

C语言的三目运算符?:本质上也是在做逻辑判断：根据条件表达式的真假，选择两个分支中的一个。它的语法是条件 ? 表达式1 : 表达式2。如果条件为真，整个表达式的值等于表达式1的值；如果为假，等于表达式2的值。

这个运算符表面上和if语句很像，但它有一个if语句无法替代的特点：它是一个表达式，可以嵌套在更大的表达式里。比如求两个数中的较大值，可以这样写：

int max = (a > b) ? a : b;

这和下面的if语句效果完全一样：

int max; if (a > b) { max = a; } else { max = b; }

三目运算符会让代码更紧凑，但过度嵌套会让你自己都看不懂自己写的代码。我个人的经验是：最多嵌套一层，再深就直接上if。比如(a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c)这种，虽然能一口气求出三者最大值，但可读性已经明显下降了。实际工程中，宁可多写几行，也别拿这种代码难为后面维护的人，包括三个月后的你。

4. if语句和switch语句的深度拆解

4.1 if语句的基本形态与三种变体

C语言的if语句有三种基本形态：单分支if、双分支if-else、多分支if-else if-else。它们解决的问题是同一个：根据条件真假，决定某段代码是否执行、以及执行哪一段。

单分支是最简单的形态：

if (score < 60) { printf("不及格\n"); }

双分支在单分支基础上增加了"不满足条件时怎么办"的处理：

if (score < 60) { printf("不及格\n"); } else { printf("及格\n"); }

多分支则是在else后面再接一个if，形成链式判断：

if (score >= 90) { printf("优秀\n"); } else if (score >= 80) { printf("良好\n"); } else if (score >= 70) { printf("中等\n"); } else if (score >= 60) { printf("及格\n"); } else { printf("不及格\n"); }

这里要注意一个细节：多分支结构中的判断顺序是从上往下依次执行的，只要一个有分支的条件为真，后面的分支就全部跳过。所以在写多分支时，条件的先后顺序要有逻辑性。比如你不能先判断score >= 60再判断score >= 90，因为90分的成绩在第一个条件就已经满足了，后面的score >= 90永远不会执行。这是个非常典型的顺序陷阱。

4.2 else的配对问题：悬空else

C语言有一条规则：else总是与离它最近的未配对的if结合。这条规则本身很简单，但在嵌套if时会产生经典的"悬空else"问题。

看这段代码：

if (a > 0) if (b > 0) printf("a和b都大于0\n"); else printf("a不大于0\n");

从代码缩进来看，写这段代码的人想让else归属外层if，也就是想表达"如果a不大于0，打印提示"。但根据C语言的配对规则，这个else实际上归属的是内层if（if (b > 0)），所以当a大于0且b不大于0时，程序反而会打印"a不大于0"。

要避免悬空else，唯一的可靠方法是给每个if都加上花括号，即使它只有一条执行语句：

if (a > 0) { if (b > 0) { printf("a和b都大于0\n"); } } else { printf("a不大于0\n"); }

加上花括号后，else的归属就一目了然了，编译器和人眼都不会再有歧义。这是我在代码规范里反复强调的一条：不管if后面的语句是单行还是多行，一律使用{}。宁写十行冗余的大括号，也不要为了省两行代码埋下隐患。

4.3 switch语句的语法结构与执行机制

switch语句是C语言里另一套分支工具，它的语法是：

switch (表达式) { case 常量1: 语句; break; case 常量2: 语句; break; default: 语句; break; }

它的执行机制是：先计算switch后面的表达式，得到一个整数值，然后从上往下依次匹配各个case后面的常量。如果匹配成功，就从那个case开始执行，直到遇到break才会跳出整个switch。如果所有case都没有匹配到，就会执行default分支（如果有的话）。

switch的匹配表达式和case常量都要求是整型或字符型，不能是浮点数，也不能是字符串。这是C语言语法笔试中经常出现的考点。很多入门者试图在switch里判断字符串，结果编译直接报错，这就是不理解switch底层机制的表现。

4.4 穿透（fall-through）现象：switch最大的坑

switch最著名的坑就是"case穿透"。当你忘记在某个case末尾写break时，程序不会在case结束后自动跳出switch，而是会继续执行下一个case里的语句。这种特性叫fall-through。

int day = 2; switch (day) { case 1: printf("周一\n"); case 2: printf("周二\n"); case 3: printf("周三\n"); default: printf("未知\n"); }

这段代码的运行结果会让新手震惊：它依次输出"周二""周三""未知"。原因就是case 2执行完没有遇到break，程序直接"穿透"继续执行case 3，再继续执行default。

穿透本身不是bug，有些场景反而可以巧妙利用它。比如判断一个月份有多少天，可以用穿透把多个case合并在一起：

switch (month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: days = 31; break; case 4: case 6: case 9: case 11: days = 30; break; case 2: days = 28; // 暂时不考虑闰年 break; default: days = 0; break; }

这种写法是穿透的标准用法，简洁又清晰。但如果是"意外穿透"，那基本就是隐藏的bug。我的建议是：每个case结束时，要么写break，要么写注释明确标注"故意穿透下一分支"。这样既能利用穿透的优势，又能尽量避免误伤。

4.5 变量的作用域与声明：switch里隐藏的编译陷阱

switch还有一个很容易让人困惑的地方，就是变量声明的作用域。在switch里直接声明变量可能会出现编译错误或跳变警告。看这个例子：

switch (op) { case '+': int result = a + b; // 某些编译器会让你在这里报错或警告 printf("%d\n", result); break; case '-': // ... break; }

问题出在C语言对变量作用域的约定上：如果在这个switch内声明了变量，那么这个变量在case之间是共享的，编译器会担心你在某个case初始化了变量，又在另一个case跳过了它，导致未初始化访问。解决办法是在需要作用域的case里加上一对花括号：

switch (op) { case '+': { int result = a + b; printf("%d\n", result); break; } case '-': { int result = a - b; printf("%d\n", result); break; } }

这种写法既让每个case拥有独立的局部变量作用域，也消除了编译器的警告和潜在风险。实际开发中，我建议所有带局部变量的case都养成加大括号的习惯。

5. 分支场景的实战拆解：什么时候用if，什么时候用switch

5.1 两种分支工具的底层对比

if语句和switch语句在功能上是可以互相替换的，但它们在表达力、效率和使用场景上有明显差异。我直接用一张表把核心区别梳理清楚：

关于效率，补充一点：现代编译器优化能力已经很强，switch语句在case数量少时和if语句的性能差异几乎可以忽略。但在case值分布密集（比如1到10连续整数）时，编译器可能会生成跳转表，这种场景下switch的效率优势就体现出来了。在单片机这种资源受限的环境里，如果有一大串连续整数需要匹配，我会优先用switch。

5.2 用菜单程序串起本项目所有知识点

我把本项目的所有知识点串到一个完整的代码例子里：一个模拟自动售货机的菜单选择程序。它用逻辑表达式做合法性判断，用switch做菜单分发，还能处理用户非法输入。完整代码和注释如下：

#include <stdio.h> int main(void) { int choice; int money = 100; int price = 0; int count = 0; int valid = 0; printf("=== 自动售货机 ===\n"); printf("1. 可乐 - 3元\n"); printf("2. 矿泉水 - 2元\n"); printf("3. 饼干 - 5元\n"); printf("4. 退卡\n"); printf("请输入你的选择(1-4): "); scanf("%d", &choice); // 利用逻辑表达式判断输入是否合法 if (choice >= 1 && choice <= 4) { valid = 1; } else { printf("无效选择，程序退出\n"); return 1; } if (valid) { switch (choice) { case 1: price = 3; count = 1; break; case 2: price = 2; count = 1; break; case 3: price = 5; count = 1; break; case 4: price = 0; printf("退出系统，再见\n"); break; default: break; } if (price > 0) { printf("你购买了商品，需要支付%d元\n", price); if (money >= price) { money -= price; printf("扣款成功，余额%d元\n", money); } else { printf("余额不足\n"); } } } return 0; }

这段程序用到了关系表达式choice >= 1 && choice <= 4做范围判断，用到了if语句做合法性分支，用到了switch语句做菜单分发，还用到了嵌套if处理余额判断。运行结果根据输入不同会有不同的输出路径，完全覆盖了本项目的核心知识点。

5.3 if和switch混用时的组织技巧

实际项目里，很少有人只用纯粹的if或者纯粹的switch，更多时候是两者混用。混用的核心原则是：外层用适合做范围判断的if，内层用适合做定值匹配的switch，或者反过来。

比如处理键盘输入的字符命令，你可以先用if判断输入是否是合法命令，再用switch针对具体命令分发：

if (cmd >= 'a' && cmd <= 'z') { switch (cmd) { case 'h': printf("帮助信息\n"); break; case 'q': printf("退出\n"); break; default: printf("未知命令\n"); break; } } else { printf("非法输入\n"); }

这种写法的好处是职责清晰：if负责边界检查，switch负责分派逻辑。我在写菜单系统、处理串口命令、做状态机的时候都是这种思路。

5.4 嵌入式环境下的分支策略补充

有些读者可能看到热搜词里有"单片机c语言"和"虚拟存储器管理"之类的词，虽然这些不是本项目的核心，但我还是想从实际经验出发补充一个嵌入式场景的细节：在单片机这类资源受限环境里写分支时，除了用if和switch，还有人会倾向用查表法或者函数指针数组来代替大量的switch分支。原因很简单，每个case的break和判断都有对应的机器指令开销，分支数量很多时，跳转表或查表法效率更高、代码也更规整。

不过对于绝大多数学习阶段和普通工程场景，if和switch已经完全够用了。我不是劝你跳过基础直接上高级技巧，恰恰相反——先把if和switch吃透，再去研究函数指针数组、状态模式这类进阶方案，才是正确的学习路径。地基不稳的时候，用再多花活都是给自己挖坑。

6. 常见问题与排查技巧实录

6.1 if条件判断失效：赋值与相等

现象：程序编译正常，运行后无论输入什么，某个分支总是执行。

排查：最典型的原因是if (x = 5)，把相等判断的==写成了赋值=。赋值表达式的结果等于被赋的那个值，所以if (x = 5)永远为真。我在调试这种问题时，第一件事就是肉眼检查条件里有没有单个等号。

提示：给编译器加上-Wall参数，GCC会对if (x = 5)给出警告，提示"assignment instead of comparison"。别忽略警告，大部分警告背后都是真实问题。

6.2 switch的default分支为什么没执行

现象：输入了一个case里没有的值，程序什么都没做就退出了，default分支没有反应。

排查：先检查default分支是大写还是小写。C语言是区分大小写的关键字，default不能写成Default或DEFAULT。再检查是否在default前面有break把程序提前跳出去了。最后检查switch后面的表达式类型和case常量类型是否一致，比如switch里放的是字符'1'，case里却写成了数字1。

6.3 逻辑表达式结果和预期相反

现象：明明条件判断是对的，程序行为却和预期完全相反。

排查：这种情况先检查有没有多写一个!。我见过有同学为了表达"不等于"写成了if (!x != 0)，因为优先级问题，它实际先对x取反，再和0比较，结果正好反转了。正确的"不等于"直接写if (x != 0)就行。另外，把条件表达式打印出来调试也是一个好办法，比如printf("%d\n", score >= 60 && score <= 90);，看看这个表达式整体输出的是1还是0。

6.4 在case里定义变量导致编译错误

现象：代码在case里写了int temp = 1;，编译器报错或者强烈警告。

排查：这是switch作用域问题，前面第4.5节已经讲过了。解决办法是在case后面加大括号，把case内所有语句括起来，形成独立的块作用域。这条规则很多教材不会重点提，但在实际写代码时几乎一定会遇到。

6.5 区间判断写成连续的比较运算符

现象：想判断x是否在0到100之间，写成了if (0 <= x <= 100)，结果程序行为莫名其妙。

排查：这是C语言初学者极高频的错误。0 <= x <= 100会先计算0 <= x，得到一个0或1的结果，再用这个结果去和100比较。由于0和1都小于100，这个表达式永远为真。正确写法是拆成两个条件，用逻辑与连接：if (x >= 0 && x <= 100)。判断区间时，一定要用逻辑运算符把两个关系表达式连接起来。

6.6 常见问题速查表

7. 从项目标题延伸出的几条学习建议

7.1 用"最小可复现实验"验证你的理解

学逻辑表达式和分支语句，最忌讳的是光看不练。我的建议是，每学完一个知识点，就写一个10行以内的最小程序去验证：你是真的理解了，还是只是记住了结论。

比如学完短路求值，就写一段代码验证1 || (1 / 0)会不会崩溃。从数学直觉上看，1 / 0是非法运算，但因为短路机制的存在，逻辑或左侧为真后右侧根本不执行，所以程序能正常运行。这种极小实验能让你对机制的印象深到骨子里。

7.2 从编译器的警告里学到最多

很多人遇到编译警告第一反应是烦躁，然后想尽办法消除警告，最后不了了之。但编译器的警告其实是最好的老师。我强烈建议你从写第一行C语言代码开始，就养成打开编译警告、阅读警告、理解警告的习惯。GCC编译器可以加-Wall -Wextra，日常练习时把这两个参数当成默认配置。

比如把字符串比较写成if (username == "admin")时，编译器会警告你比较的是指针而不是字符串内容。这种警告等于是在手把手教你："这里写法有问题，仔细想想。"几年下来，大部分实际工程项目里的疑难杂症，你靠着"认真对待编译警告"这一个习惯就能躲开一大半。

7.3 尝试把同一个逻辑用多种思路实现

标题里的知识点有一个很好的练习方式：拿同一个场景，分别用if和switch各写一版，比较两者的差异。比如用if写一个判断1到7对应星期几的程序，再用switch写一遍，然后对比代码行数、可读性和扩展性。

这种对比练习做多了，你就能形成一种直觉：什么时候用if，什么时候用switch，根本不用刻意去记规则。这种直觉在真实项目中特别值钱，因为代码写出来是给人维护的，能找到最符合人类思维习惯的写法，比单纯追求"能跑"高了一个维度。

8. 最后分享一个实际开发里的小技巧

我在实际项目里踩过很多次分支结构的坑，绕了很远的路。这里想分享一个特别实用的小经验：如果你发现一个if-else链里面的分支越来越多，比如超过四五个，先别急着继续往下加else if，停下来想想能不能用switch重构，或者查表法。

写一个四个以内的else if没问题，再多就会让代码变得越来越难读。我有一次接手一个别人的消息处理函数，里面的else if写了十几个，每个分支还带着各种边界条件，读起来跟绕迷宫一样，维护成本极高。后来我根据消息类型字段，把十几个分支改成switch加几个小函数的组合，整个文件的代码减少了一半，逻辑复杂度直线下降。

另外，如果你不确定一个表达式的执行顺序，不要靠记忆硬扛，直接在代码里加个括号，把你想强调的结合关系写清楚。C语言本身给了你自由，但从可维护性的角度，这种自由有时反而是负担。写代码时多用眼睛看一遍"如果三个月后的我看这段代码，能秒懂吗"，很多时候你就能避开那些慢慢积累的坏味道。

本项目的六个关键词——逻辑量、逻辑运算符、逻辑表达式、if语句、switch语句——到这儿就全部讲完了。剩下的就靠你自己多写、多试、多踩坑、多总结，这些东西才能真正变成你自己的。