【C 语言系统入门教程】第 3 讲：分支和循环（上） | 零基础学习笔记
本系列为 C 语言零基础系统学习笔记，配套课程课件内容，持续更新中～本文为系列第 3 讲，是 C 语言结构化程序设计的核心篇章，完整覆盖分支结构、循环结构两大核心程序逻辑，从基础语法到代码实操，拆解 if、switch、三大循环、break/continue 等核心语法，带你从 “写得出代码” 进阶到 “写得好逻辑”，全程零基础友好，可直接复制代码运行调试。
系列往期笔记：第 1 讲：C 语言常见概念 | 第 2 讲：C 语言数据类型和变量
🎯 本讲学习目标
掌握
if分支语句的完整用法，包括单分支、双分支、多分支嵌套，彻底规避悬空 else的经典坑点熟练使用 6 种关系操作符，区分
==与=的核心差异，规避关系运算符连用的逻辑错误掌握条件操作符（三目运算符）的语法与使用场景，能简化简单的分支代码
掌握
!、&&、||三大逻辑操作符，理解短路求值的底层原理，能完成复杂逻辑表达式的编写掌握
switch分支语句的语法规则，明确break与default的核心作用，能根据场景选择 if/switch 实现分支掌握
while、for、do-while三大循环的语法、执行流程与核心差异，能根据场景选择合适的循环熟练运用
break和continue关键字控制循环执行流程，明确二者在不同循环中的行为差异掌握循环嵌套的编写逻辑，能完成素数判断等基础嵌套循环场景
了解
goto语句的语法、适用场景与使用禁忌，规避滥用 goto 导致的代码逻辑混乱
📚 核心学习内容
C 语言是结构化的程序设计语言，核心支持三种程序结构：顺序结构、选择结构（分支）、循环结构。
分支结构：使用
if、switch语句实现，根据条件判断执行不同的代码逻辑循环结构：使用
for、while、do-while语句实现，让代码重复执行，减少冗余
1. if 语句
if语句是 C 语言中最基础、最常用的分支实现方式，通过条件表达式的真假，决定代码是否执行。
C 语言中，0 表示假，非 0 表示真：表达式结果为 0，语句不执行；结果为非 0，语句执行。
1.1 单分支 if 语句
语法格式
if (表达式) 语句;表达式成立（为真），则执行语句；表达式不成立（为假），语句不执行
若需要控制多条语句，必须用
{}包裹成复合语句（代码块）
代码实操：判断奇数
#include <stdio.h> int main() { int num = 0; scanf("%d", &num); // 判断是否为奇数：对2取余结果为1 if(num % 2 == 1) printf("%d 是奇数\n", num); return 0; }1.2 双分支 if...else 语句
当条件成立和不成立时，需要执行不同的逻辑，使用if...else...双分支结构。
语法格式
if (表达式) 语句1; else 语句2;表达式为真，执行语句 1；表达式为假，执行语句 2
二者只会执行其中一个，不会同时执行
代码实操：判断奇数 / 偶数
#include <stdio.h> int main() { int num = 0; scanf("%d", &num); if(num % 2 == 1) printf("%d 是奇数\n", num); else printf("%d 是偶数\n", num); return 0; }1.3 分支中包含多条语句
if和else默认只能控制一条语句，如果需要控制多条语句，必须使用{}将代码包裹成复合语句（代码块），否则会出现逻辑错误。
错误示例
#include <stdio.h> int main() { int age = 0; scanf("%d", &age); // 错误：if只能控制第一行printf，第二行无论条件真假都会执行 if(age >= 18) printf("成年了\n"); printf("可以谈恋爱了\n"); return 0; }问题：无论输入的年龄是否≥18，
"可以谈恋爱了"都会被打印，因为 if 无法控制第二行语句。
正确示例
#include <stdio.h> int main() { int age = 0; scanf("%d", &age); // 用{}包裹多条语句，if可控制整个代码块 if(age >= 18) { printf("成年了\n"); printf("可以谈恋爱了\n"); } else { printf("未成年\n"); printf("不可以早恋哦\n"); } return 0; }❗ 高频易错点提醒：即使 if/else 后只有一条语句，也建议加上
{}，养成良好的代码规范，避免后续新增代码时出现逻辑错误。
1.4 嵌套 if
在if else语句中，else可以与另一个if语句连用，构成多重判断，实现更复杂的分支逻辑。
代码实操 1：判断数字是 0、正数还是负数
#include <stdio.h> int main() { int num = 0; scanf("%d", &num); if(num == 0) printf("输入的数字是0\n"); else if(num > 0) // if嵌套在else中，构成多分支 printf("输入的数字是正数\n"); else printf("输入的数字是负数\n"); return 0; }代码实操 2：年龄段分级判断
需求：输入年龄，<18 岁打印少年，18-44 岁打印青年，45-59 岁打印中老年，60-89 岁打印老年，90 岁及以上打印老寿星。
#include <stdio.h> int main() { int age = 0; scanf("%d", &age); if(age < 18) { printf("少年\n"); } else if(age <= 44) { printf("青年\n"); } else if(age <= 59) { printf("中老年\n"); } else if(age <= 89) { printf("老年\n"); } else { printf("老寿星\n"); } return 0; }1.5 悬空 else 问题
这是 if 语句的经典坑点，必须牢记核心规则：else 总是跟最接近的、未匹配的 if 匹配，与代码排版无关。
经典错误示例
#include <stdio.h> int main() { int a = 0; int b = 2; if(a == 1) if(b == 2) printf("hehe\n"); else // 视觉上与第一个if对齐，实际与第二个if匹配 printf("haha\n"); return 0; }新手误区：认为 a=0，第一个 if 不成立，会执行 else 打印 haha；实际运行结果：什么都不输出。
核心原因：else 与最接近的第二个 if 匹配，整个
if(b==2)...else...都嵌套在第一个 if 中，第一个 if 不成立，内部代码完全不会执行。
正确写法：用 {} 明确代码块边界
#include <stdio.h> int main() { int a = 0; int b = 2; // 希望else与第一个if匹配，用{}明确边界 if(a == 1) { if(b == 2) printf("hehe\n"); } else { printf("haha\n"); } return 0; }✅ 最佳实践：无论 if/else 后有几条语句，都用
{}包裹代码块，彻底规避悬空 else 问题，提升代码可读性。
2. 关系操作符
C 语言中用于比较的表达式称为 “关系表达式”，里面使用的运算符称为 “关系操作符”，共 6 个，用于实现分支 / 循环的条件判断。
| 关系操作符 | 含义 | 示例 | 结果（真返回 1，假返回 0） |
|---|---|---|---|
> | 大于 | 5 > 3 | 1 |
< | 小于 | 5 < 3 | 0 |
>= | 大于等于 | 5 >= 5 | 1 |
<= | 小于等于 | 5 <= 3 | 0 |
== | 相等 | 5 == 5 | 1 |
!= | 不相等 | 5 != 3 | 1 |
核心特性
关系表达式的返回值只有两种：1（真）和0（假）
常用于 if、while 等结构的条件判断
高频易错点
混淆相等运算符
==和赋值运算符=错误写法：
if(x = 3)，含义是给 x 赋值 3，表达式返回值为 3（非 0，恒为真），会导致条件判断永远成立正确写法：
if(x == 3)，含义是判断 x 是否等于 3防错技巧：将常量写在左边，
if(3 == x)，如果误写为3 = x，编译器会直接报错，提前规避问题。
多个关系运算符连用
关系运算符是从左到右计算的，多个连用无法达到 “判断区间” 的效果，会出现逻辑错误。
错误示例：判断年龄是否在 18~36 岁之间
// 错误：输入10时，依然会打印"青年" if(18 <= age <= 36) { printf("青年\n"); }执行逻辑：先计算
18 <= 10，结果为 0（假）；再计算0 <= 36，结果为 1（真），最终条件成立，逻辑完全错误。正确写法：用逻辑与运算符
&&连接两个条件
// 正确：同时满足两个条件，才会成立 if(age >= 18 && age <= 36) { printf("青年\n"); }
3. 条件操作符
条件操作符也叫三目操作符，是 C 语言中唯一需要 3 个操作数的运算符，用于简化简单的 if-else 双分支代码。
语法格式
exp1 ? exp2 : exp3执行逻辑
如果
exp1为真，执行exp2，exp2的结果就是整个表达式的结果如果
exp1为假，执行exp3，exp3的结果就是整个表达式的结果
代码实操
示例 1：简化 if-else 分支
// 原始if-else写法 #include <stdio.h> int main() { int a = 0; int b = 0; scanf("%d", &a); if(a > 5) b = 3; else b = -3; printf("%d\n", b); return 0; } // 条件操作符简化写法 #include <stdio.h> int main() { int a = 0; int b = 0; scanf("%d", &a); b = a > 5 ? 3 : -3; // 一行代码实现双分支逻辑 printf("%d\n", b); return 0; }示例 2：找两个数中的较大值
#include <stdio.h> int main() { int a = 0; int b = 0; scanf("%d %d", &a, &b); int max = a > b ? a : b; // 三目运算符取最大值 printf("较大值：%d\n", max); return 0; }使用建议：仅用于简化简单的双分支逻辑，复杂分支不建议使用，否则会降低代码可读性。
4. 逻辑操作符: && , || , !
逻辑运算符用于构建复杂的条件判断，实现 “并且、或者、取反” 的逻辑关系，共 3 个。
核心规则：C 语言中，非 0 表示真，0 表示假。
4.1 逻辑取反运算符！
单目操作符，用于翻转单个表达式的真假：真变假，假变真。
| 表达式 a | !a |
|---|---|
| 非 0（真） | 0（假） |
| 0（假） | 1（真） |
代码实操
#include <stdio.h> int main() { int flag = 0; // 如果flag为假，执行代码 if(!flag) { printf("do something\n"); } return 0; }4.2 逻辑与运算符 &&
双目操作符，表示并且的含义，只有两侧的表达式都为真，整个表达式才为真；只要有一个为假，整个表达式就为假。
| 表达式 a | 表达式 b | a && b |
|---|---|---|
| 非 0（真） | 非 0（真） | 1（真） |
| 非 0（真） | 0（假） | 0（假） |
| 0（假） | 非 0（真） | 0（假） |
| 0（假） | 0（假） | 0（假） |
代码实操：判断春季
#include <stdio.h> int main() { int month = 0; scanf("%d", &month); // 3月~5月是春季，必须同时满足两个条件 if(month >= 3 && month <= 5) { printf("春季\n"); } return 0; }4.3 逻辑或运算符 ||
双目操作符，表示或者的含义，两侧的表达式只要有一个为真，整个表达式就为真；只有两侧都为假，整个表达式才为假。
| 表达式 a | 表达式 b | a || b |
|---|---|---|
| 非 0（真） | 非 0（真） | 1（真） |
| 非 0（真） | 0（假） | 1（真） |
| 0（假） | 非 0（真） | 1（真） |
| 0（假） | 0（假） | 0（假） |
代码实操：判断冬季
#include <stdio.h> int main() { int month = 0; scanf("%d", &month); // 12月、1月、2月是冬季，满足任意一个条件即可 if(month == 12 || month == 1 || month == 2) { printf("冬季\n"); } return 0; }4.4 经典实战：闰年判断
闰年判断规则
能被 4 整除，并且不能被 100 整除，是闰年
能被 400 整除，是闰年
参考代码
#include <stdio.h> int main() { int year = 0; scanf("%d", &year); // 两个条件满足任意一个，就是闰年 if((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) { printf("是闰年\n"); } else { printf("不是闰年\n"); } return 0; }4.5 核心重点：短路求值
逻辑运算符有一个关键特性：总是先对左侧表达式求值，再对右侧表达式求值；如果左侧表达式已经能确定整个表达式的结果，就不再对右侧表达式求值，这种现象称为短路。
短路规则
逻辑与 &&：左侧表达式为假时，整个表达式结果必然为假，右侧表达式不再执行
逻辑或 ||：左侧表达式为真时，整个表达式结果必然为真，右侧表达式不再执行
代码实操：短路验证
#include <stdio.h> int main() { int i = 0, a = 0, b = 2, c = 3, d = 4; // 逻辑与短路：a++结果为0（假），右侧++b、d++都不会执行 i = a++ && ++b && d++; printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d); // 输出结果：a=1，b=2，c=3，d=4 return 0; }#include <stdio.h> int main() { int i = 0, a = 0, b = 2, c = 3, d = 4; // 逻辑或短路：a++结果为0，继续执行++b，结果为3（真），右侧d++不再执行 i = a++ || ++b || d++; printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d); // 输出结果：a=1，b=3，c=3，d=4 return 0; }❗ 易错点提醒：不要在逻辑运算符的右侧编写会改变变量值的表达式，否则短路会导致预期外的结果，出现逻辑 bug。
5. switch 语句
switch语句是 C 语言提供的另一种分支结构，专门用于条件有多个固定结果的场景，相比多重if else，代码更简洁、可读性更高。
5.1 语法格式
switch (整型表达式) { case 整型常量表达式1: 语句1; break; case 整型常量表达式2: 语句2; break; // 多个case分支... default: 默认语句; break; }核心语法规则
switch后的表达式必须是整型表达式（字符型本质是 ASCII 码，也属于整型）case后的值必须是整型常量表达式，不能是变量case和后面的数字之间必须有空格每个
case分支执行完成后，需要用break跳出 switch 语句
5.2 if 语句与 switch 语句对比
需求：输入任意整数，计算除以 3 之后的余数并打印。
if 语句实现
#include <stdio.h> int main() { int n = 0; scanf("%d", &n); if(n % 3 == 0) printf("整除，余数为0\n"); else if(n % 3 == 1) printf("余数是1\n"); else printf("余数是2\n"); return 0; }switch 语句实现
#include <stdio.h> int main() { int n = 0; scanf("%d", &n); switch(n % 3) // 表达式结果为0、1、2三个固定值 { case 0: printf("整除，余数为0\n"); break; case 1: printf("余数是1\n"); break; case 2: printf("余数是2\n"); break; } return 0; }5.3 switch 语句中的 break
break的核心作用是跳出 switch 语句，实现真正的分支效果。如果case后没有break，代码会继续向下执行，穿透到后续的case分支，直到遇到break或 switch 语句结束。
错误示例：缺少 break 导致分支穿透
#include <stdio.h> int main() { int n = 7; switch(n % 3) // 7%3=1，匹配case1 { case 0: printf("整除，余数为0\n"); case 1: printf("余数是1\n"); // 执行后无break，继续向下执行 case 2: printf("余数是2\n"); // 被意外执行 } return 0; }运行结果：同时打印
余数是1和余数是2，出现逻辑错误。
分支穿透的合理使用
多个 case 分支需要执行相同逻辑时，可以利用分支穿透特性，省略重复代码。
需求：输入 1~7 的数字，1~5 打印 “工作日”，6~7 打印 “休息日”，其他数字提示输入错误。
#include <stdio.h> int main() { int day = 0; scanf("%d", &day); switch(day) { // 多个case共用同一套逻辑，利用分支穿透 case 1: case 2: case 3: case 4: case 5: printf("工作日\n"); break; case 6: case 7: printf("休息日\n"); break; default: printf("输入错误\n"); break; } return 0; }5.4 switch 语句中的 default
default分支用于处理switch表达式的值无法匹配所有case的场景，相当于 if-else 中的else。
default没有固定的位置要求，可以放在 switch 语句的任意位置，通常放在最后即使
default放在最后，也建议加上break，避免后续新增 case 分支时出现穿透问题
5.5 高频易错点汇总
switch后使用非整型表达式，如浮点型，会编译报错case后使用变量，必须使用整型常量表达式遗漏
break导致分支穿透，出现逻辑错误多个
case使用相同的值，会出现编译冲突字符型 case 值使用双引号，必须使用单引号（如
case 'a'）
6. while 循环
循环结构用于让代码重复执行，避免冗余代码，while是 C 语言中最基础的循环语句，语法结构与 if 语句高度相似。
6.1 if 与 while 的核心区别
// if语句：条件成立，语句仅执行1次 if(表达式) 语句; // while语句：条件成立，语句重复执行，直到条件不成立 while(表达式) 语句;6.2 while 循环执行流程
执行判断表达式，值为 0，循环直接结束；值为非 0，执行循环体语句
循环体语句执行完成后，再次回到表达式判断，重复上述流程
直到表达式结果为 0，循环终止
6.3 代码实操：打印 1~10
#include <stdio.h> int main() { int i = 1; // 循环变量初始化 while(i <= 10) // 循环结束条件判断 { printf("%d ", i); i = i + 1; // 循环变量调整 } return 0; }运行结果：
1 2 3 4 5 6 7 8 9 10
6.4 进阶实战：逆序打印整数的每一位
需求：输入一个正整数，逆序打印每一位，如输入 1234，输出 4 3 2 1。
#include <stdio.h> int main() { int n = 0; scanf("%d", &n); while(n) // n不为0时，持续循环 { printf("%d ", n % 10); // 取最低位 n /= 10; // 去掉最低位 } return 0; }7. for 循环
for循环是 C 语言中使用最频繁的循环语句，将循环的初始化、判断、调整三个核心部分集中在一起，代码更紧凑、维护更方便。
7.1 语法格式
for(表达式1; 表达式2; 表达式3) 语句;表达式 1：循环变量的初始化，整个循环仅执行 1 次
表达式 2：循环结束条件的判断，每次循环前执行，结果为非 0 进入循环，为 0 结束循环
表达式 3：循环变量的调整，每次循环体执行完后执行
7.2 for 循环执行流程
执行表达式 1，完成循环变量初始化（仅执行 1 次）
执行表达式 2，判断循环条件：结果为 0，循环结束；结果为非 0，执行循环体语句
循环体执行完成后，执行表达式 3，调整循环变量
再次回到表达式 2，重复判断、执行、调整的流程，直到表达式 2 结果为 0，循环终止
7.3 代码实操：打印 1~10
#include <stdio.h> int main() { int i = 0; // 初始化、判断、调整集中在一行 for(i = 1; i <= 10; i++) { printf("%d ", i); } return 0; }7.4 for 循环与 while 循环的对比
| 循环核心步骤 | while 循环 | for 循环 |
|---|---|---|
| 初始化 | 循环外单独执行 | 表达式 1，循环头部集中执行 |
| 条件判断 | 循环头部 | 表达式 2，循环头部集中执行 |
| 变量调整 | 循环体内执行 | 表达式 3，循环头部集中执行 |
核心优势：for 循环将三个核心部分集中在一起，代码量大时，可读性和可维护性远高于 while 循环，优先推荐使用 for 循环。
7.5 进阶实战：计算 1~100 之间 3 的倍数之和
#include <stdio.h> int main() { int i = 0; int sum = 0; // 优化：直接生成3的倍数，省去多余的判断 for(i = 3; i <= 100; i += 3) { sum += i; } printf("1~100之间3的倍数之和：%d\n", sum); return 0; }8. do-while 循环
do-while循环是三种循环中使用最少的，核心特性是先执行循环体，再判断循环条件，循环体至少会执行 1 次。
8.1 语法格式
do { 语句; } while(表达式);注意：while (表达式) 末尾的分号
;绝对不能省略，否则会编译报错。
8.2 do-while 循环执行流程
先直接执行循环体语句
执行 while 后的判断表达式：结果为非 0，再次执行循环体；结果为 0，循环结束
8.3 代码实操：打印 1~10
#include <stdio.h> int main() { int i = 1; do { printf("%d ", i); i = i + 1; } while(i <= 10); // 末尾分号不能省略 return 0; }8.4 进阶实战：计算整数的位数
需求：输入一个正整数，计算这个数是几位数，如输入 1234，输出 4。
#include <stdio.h> int main() { int n = 0; scanf("%d", &n); int cnt = 0; // 即使n=0，也是1位数，do-while完美适配 do { cnt++; n = n / 10; } while(n); printf("数字的位数：%d\n", cnt); return 0; }适用场景：仅用于循环体至少需要执行 1 次的场景，日常开发中使用频率较低，优先使用 for/while 循环。
9. break 和 continue 语句
在循环执行过程中，需要提前终止循环或跳过本次循环时，使用break和continue两个关键字，二者的作用有本质区别。
| 关键字 | 核心作用 |
|---|---|
break | 永久终止当前所在的第一层循环，直接跳出循环，执行循环后的代码 |
continue | 跳过本次循环中 continue 后面的代码，直接进入下一次循环的条件判断 |
9.1 while 循环中的 break 和 continue
break 示例：提前终止循环
#include <stdio.h> int main() { int i = 1; while(i <= 10) { if(i == 5) break; // i等于5时，直接终止整个循环 printf("%d ", i); i++; } return 0; }运行结果：
1 2 3 4，i=5 时触发 break，循环永久终止，后续内容不再执行。
continue 示例：跳过本次循环
#include <stdio.h> int main() { int i = 1; while(i <= 10) { if(i == 5) continue; // i等于5时，跳过后面的代码，直接进入下一次判断 printf("%d ", i); i++; } return 0; }运行结果：
1 2 3 4，之后程序陷入死循环。核心原因：continue 跳过了
i++，i 的值永远为 5，循环条件永远成立，陷入死循环。
9.2 for 循环中的 break 和 continue
break 示例
#include <stdio.h> int main() { int i = 1; for(i = 1; i <= 10; i++) { if(i == 5) break; // 终止整个循环 printf("%d ", i); } return 0; }运行结果：
1 2 3 4，与 while 循环中行为一致。
continue 示例
#include <stdio.h> int main() { int i = 1; for(i = 1; i <= 10; i++) { if(i == 5) continue; // 跳过后面的打印，直接执行i++ printf("%d ", i); } return 0; }运行结果：
1 2 3 4 6 7 8 9 10，仅跳过了 i=5 的打印，不会陷入死循环。核心原因：for 循环中，continue 跳过循环体代码后，会直接执行表达式 3（i++）调整循环变量，不会出现 while 循环中的死循环问题。
9.3 do-while 循环中的 break 和 continue
do-while循环中的break和continue，行为与while循环中几乎完全一致，continue依然需要注意循环变量调整的位置，避免死循环。
10. 循环的嵌套
循环内部可以嵌套另一个循环，称为循环嵌套，用于解决更复杂的重复逻辑问题，三种循环（for/while/do-while）可以互相嵌套，最常用的是 for 循环嵌套。
经典实战：找出 100~200 之间的素数并打印
素数（质数）定义：只能被 1 和它本身整除的正整数。
解题思路
外层循环：生成 100~200 之间的所有数字
内层循环：用 2~i-1 之间的数字试除当前数字 i，判断是否能被整除
标记位：用 flag 标记是否为素数，初始假设为素数（flag=1），如果能被整除，标记为非素数（flag=0）并终止内层循环
参考代码
#include <stdio.h> int main() { int i = 0; // 外层循环：遍历100~200的所有数字 for(i = 100; i <= 200; i++) { int j = 0; int flag = 1; // 标记位，假设i是素数，初始值为1 // 内层循环：判断i是否为素数 for(j = 2; j < i; j++) { if(i % j == 0) { flag = 0; // 能被整除，不是素数 break; // 提前终止内层循环，无需继续判断 } } // 标记位为1，说明是素数，打印 if(flag == 1) printf("%d ", i); } return 0; }11. goto 语句
goto语句是 C 语言提供的跳转语法，可以在同一个函数内，跳转到设置好的标号处。
11.1 语法格式
goto 标号名; ... 标号名: 语句;代码实操：基础跳转
#include <stdio.h> int main() { printf("hehe\n"); goto next; // 跳转到next标号处 printf("haha\n"); // 被跳过，不会执行 next: printf("跳过了haha的打印\n"); return 0; }11.2 适用场景与使用禁忌
滥用的危害
goto语句如果使用不当，会导致函数内部随意乱跳转，彻底打乱程序的执行流程，让代码可读性极差、难以维护、bug 频发，因此日常开发中，能不用就尽量不用。
唯一推荐使用场景
在多层循环嵌套中，需要快速跳出所有循环时，使用goto比多个break更简洁高效。
一个 break 只能跳出一层循环，3 层循环嵌套需要 3 个 break 才能跳出，而 goto 可以一次直接跳出所有循环。
for(...) { for(...) { for(...) { if(异常情况) goto error; // 一次跳出3层循环 } } } error: // 异常处理代码✍️ 课后习题与参考答案
一、选择题
下列关于 if 语句的说法，正确的是（ ）
A. if 语句只能控制一条语句，无论是否使用 {}
B. else 总是与代码排版上对齐的 if 进行匹配
C. if 语句的条件表达式中，0 表示假，非 0 表示真
D. if 语句中不能嵌套另一个 if 语句
下列表达式中，能正确判断 x 是否在 [10, 20] 区间内的是（ ）
A.
10 <= x <= 20B.
x >= 10 && x <= 20C.
x >= 10 || x <= 20D.
10 <= x && x <= 20下列代码的运行结果是（ ）
#include <stdio.h> int main() { int a = 0, b = 1; if(a++ && b++) printf("true\n"); printf("a=%d,b=%d\n", a, b); return 0; }A. true a=1,b=2
B. a=1,b=1
C. a=0,b=1
D. true a=0,b=1
switch 语句中，case 后必须跟随的是（ ）
A. 变量
B. 整型常量表达式
C. 任意表达式
D. 字符串
下列关于三大循环的说法，错误的是（ ）
A. for 循环的初始化部分仅在循环开始时执行 1 次
B. while 循环是先判断条件，后执行循环体
C. do-while 循环的循环体至少会执行 1 次
D. while 循环和 for 循环中，continue 的行为完全一致
在循环中，想要永久终止当前循环，应该使用的关键字是（ ）
A. continue
B. break
C. goto
D. return
二、判断题
关系运算符
==和赋值运算符=可以互换使用，效果一致。（ ）逻辑与
&&运算符中，只要左侧表达式为假，右侧表达式就不会执行。（ ）switch 语句中，default 分支必须放在所有 case 分支的最后，否则会编译报错。（ ）
for 循环的三个表达式都可以省略，写成
for(;;)会形成死循环。（ ）continue 语句的作用是终止整个循环的执行。（ ）
goto 语句可以在不同函数之间随意跳转。（ ）
三、编程题
编写程序，输入一个整数，判断它是正数、负数还是 0，使用 if-else 语句实现。
编写程序，输入一个学生的成绩（0100），输出对应的等级：90100 为 A，80~89 为 B，70~79 为 C，60~69 为 D，0~59 为 E，分别用 if-else if 和 switch 语句两种方式实现。
编写程序，计算 1~100 之间所有偶数的和，分别用 while、for、do-while 三种循环实现。
编写程序，打印 100~200 之间所有能被 3 整除且个位数字是 5 的数。
编写程序，打印九九乘法表，使用循环嵌套实现。
参考答案
一、选择题
C 2. B 3. B 4. B 5. D 6. B
二、判断题
×（二者功能完全不同，
==用于判断相等，=用于赋值，不可互换）√（逻辑与的短路求值特性，左侧为假，右侧不执行）
×（default 分支没有固定位置要求，可以放在 switch 语句的任意位置）
√（for 循环省略三个表达式后，判断条件恒为真，形成死循环）
×（continue 仅跳过本次循环后续代码，进入下一次循环判断；break 才是终止整个循环）
×（goto 语句只能在同一个函数内跳转，不能跨函数跳转）
三、编程题
1、参考代码
#include <stdio.h> int main() { int num = 0; scanf("%d", &num); if(num > 0) printf("正数\n"); else if(num < 0) printf("负数\n"); else printf("0\n"); return 0; }2、参考代码
if-else if 实现
#include <stdio.h> int main() { int score = 0; scanf("%d", &score); if(score < 0 || score > 100) { printf("输入的成绩无效\n"); } else if(score >= 90) { printf("A\n"); } else if(score >= 80) { printf("B\n"); } else if(score >= 70) { printf("C\n"); } else if(score >= 60) { printf("D\n"); } else { printf("E\n"); } return 0; }switch 语句实现
#include <stdio.h> int main() { int score = 0; scanf("%d", &score); if(score < 0 || score > 100) { printf("输入的成绩无效\n"); return 0; } // 利用整除特性，将0~100映射为0~10的固定值 switch(score / 10) { case 10: case 9: printf("A\n"); break; case 8: printf("B\n"); break; case 7: printf("C\n"); break; case 6: printf("D\n"); break; default: printf("E\n"); break; } return 0; }3、参考代码
while 循环实现
#include <stdio.h> int main() { int i = 1, sum = 0; while(i <= 100) { if(i % 2 == 0) sum += i; i++; } printf("1~100偶数和：%d\n", sum); return 0; }for 循环实现
#include <stdio.h> int main() { int i = 0, sum = 0; for(i = 2; i <= 100; i += 2) { sum += i; } printf("1~100偶数和：%d\n", sum); return 0; }do-while 循环实现
#include <stdio.h> int main() { int i = 1, sum = 0; do { if(i % 2 == 0) sum += i; i++; } while(i <= 100); printf("1~100偶数和：%d\n", sum); return 0; }4、参考代码
#include <stdio.h> int main() { int i = 0; for(i = 100; i <= 200; i++) { // 能被3整除，且个位是5 if(i % 3 == 0 && i % 10 == 5) { printf("%d ", i); } } return 0; }5、参考代码
#include <stdio.h> int main() { int i = 0, j = 0; // 外层循环控制行 for(i = 1; i <= 9; i++) { // 内层循环控制列 for(j = 1; j <= i; j++) { printf("%d*%d=%d\t", j, i, i*j); } printf("\n"); // 每行结束换行 } return 0; }📝 本讲核心总结
本讲是 C 语言从基础语法到程序逻辑的核心转折点，我们完整覆盖了分支结构和循环结构两大核心程序设计模块，核心知识点可提炼为 3 大核心：
分支结构：实现程序的选择逻辑
if语句适配所有分支场景，单分支、双分支、多分支嵌套均可实现，重点规避悬空 else、==与=混淆的坑点switch语句适配多固定值的分支场景，核心是break实现分支隔离、default处理异常情况，合理利用分支穿透可简化重复代码关系操作符、逻辑操作符是分支条件的核心，重点掌握逻辑运算符的短路求值特性，避免写出有隐藏 bug 的表达式
循环结构：实现代码的重复执行
三大循环各有适用场景：
for循环将初始化、判断、调整集中在一起，日常开发优先使用；while循环适用于循环次数不固定的场景；do-while循环仅适用于循环体至少执行 1 次的场景break和continue是循环控制的核心：break永久终止循环，continue跳过本次循环后续代码，重点区分二者在while和for循环中的行为差异循环嵌套是复杂逻辑的实现基础，核心是理清外层循环与内层循环的职责，避免嵌套层级过多导致代码可读性下降
结构化程序设计思想
C 语言的三大程序结构（顺序、分支、循环），可以拆解和实现现实中所有的业务逻辑。本讲的所有语法，最终目标都是让你写出逻辑清晰、结构合理、可维护的代码，而非单纯的语法记忆。后续的函数、数组、指针等知识点，都将基于这三大结构展开，务必吃透本讲内容，多动手写代码练习，形成肌肉记忆。
本系列笔记持续更新，下一讲将通过经典的「猜数字游戏」实战，带你落地分支与循环的综合应用，完成从语法到项目的跨越～
📌 版权说明
本文为个人学习笔记整理，配套课程课件内容，未经允许禁止转载，如有错误欢迎评论区指正～
