嵌入式学习（五）--C语言（第三章）（流程控制）-CSDN博客

5 > 3                         // 判断 5 是否大于 3，结果为真（1）

7 < 2                         // 判断 7 是否小于 2，结果为假（0）

10 >= 10                   // 判断 10 是否大于等于 10，结果为真（1）

6 <= 4                       // 判断 6 是否小于等于 4，结果为假（0）

3 == 3                       // 判断 3 是否等于 3，结果为真（1）

5 != 8                        // 判断 5 是否不等于 8，结果为真（1）

a > b // 判断变量 a 的值是否大于变量 b 的值

x <= y + 2                 // 判断变量 x 的值是否小于等于 y+2 的结果

2. 逻辑运算符

○ 截断特性：

■ 逻辑与左边为假，右边不再计算

■ 逻辑或左边为真，右边不再计算

运算符	含义
&&	逻辑与（既..又..）
\|\|	逻辑或（要么..要么..）
!	逻辑非（真取非得假、假取非得真）

○ &&真值表：一假为假，全真为真

左	右	真值表
真	真	真
真	假	假
假	真	假
假	假	假

○ || 真值表：一真为真，全假为假

左	右	真值表
真	真	真
假	真	真
真	假	真
假	假	假

○ ! ：真取非得假，假取非得真

3. 三目运算符

○ 三目运算符结合方向自右至左

例如：a ？ b : c ? d : e
会被解析为：a ? b : (c ? d : e)，而非 (a ? b : c) ? d : e

○ 逻辑表达式 ? 表达式1 : 表达式2;

■ 示例

/* 若 a 大于 b，max 等于 a，否则等于 b */
max = a > b ? a : b;

/* 若 score 大于等于 60，result 为 "及格"，否则为 "不及格" */
result = score >= 60 ? "及格" : "不及格";

/* 若 x 等于 0，num 为 100，否则 num 等于 x */
num = x == 0 ? 100 : x;

/* 嵌套使用，n 为正 sign 是 1，为负是 - 1，为 0 则是 0 */
sign = n > 0 ? 1 : (n < 0 ? -1 : 0);

/* 若 a 是偶数输出 "偶数"，否则输出 "奇数 */
(a % 2 == 0) ? printf("偶数") : printf("奇数");

三、分支结构

1. if 分支

○ 实现判断逻辑，用if分支

○ 同一类数据执行不同操作，用if分支

1）简单分支：

■ if 后面必须加表达式，else 后面不能加表达式

■ if 可以脱离 else 单独使用，但是 else 不能脱离if单独使用

■ if 和 else 不加大扩号默认控制一句代码，最好加上大括号

if (表达式)
{
    语句块1;
}
else 
{
    语句块2;
}

■ 示例

/* 比较两数，若第一个数大则打印第一个数，反之则交换 */
if (a <= b) 
{
    temp = a;
    a = b;
    b = temp;
}

printf("结果: %d\n", a);

2）阶梯分支：

if (表达式1)
{
    语句块1;
}
else if (表达式2)
{
    语句块2;
}
else if (表达式3)
{
    语句块3;
}
else 
{
    语句块4;
}

3）嵌套分支：

■ 尽量避免深层次嵌套（最多嵌套 3 - 5 层）

if (表达式1)
{
    语句块1;
    if (表达式2)
    {
        语句块2;
        if (表达式3)
        {
            语句块3
        }
    }
    else 
    {
        语句块4;
    }
}
else 
{
    语句块5;
}

2. switch 分支

1）基本形式：

■ switch 后面必须为整形表达式

■ case 后面必须为常量，不能为变量或者表达式

■ switch与case后面的值比一次，然后顺序向下执行直到遇到break,或者switch结束才会停止

switch (整形表达式)
 {
    case 常量1:语句块1;break;
    case 常量2:语句块2;break;
    case 常量3:语句块3;break;
    default:
        语句块4;
 }

■ 示例

/*
从终端接收一个分数
90 - 100  打印   S
80 - 89   打印   A
70 - 79   打印   B
60 - 69   打印   C
60以下    打印   D
*/
switch (score / 10) 
{
    case 10:              // 100分的情况（100/10=10）
    case 9:               // 90-99分（90/10=9到99/10=9）
        printf("S\n");
        break;
    case 8:               // 80-89分
        printf("A\n");
        break;
    case 7:               // 70-79分
        printf("B\n");
        break;    
    case 6:               // 60-69分
        printf("C\n");
        break;
    default:              // 0-59分（涵盖所有其他情况）
        printf("D\n");
}

2）嵌套形式：

■ 双层switch中，里层结束后，不加break，外层switch会继续向下执行

四、循环结构

● 重复执行某段代码，使用循环

● 有规律的代码使用循环

● 已知循环次数用for循环

● 未知循环次数用while循环

1. while 循环

1）基本形式：

while (表达式)
{
    语句块:
}

2）执行流程：

■ 先判断 () 中的循环条件（结果为非 0 表示真，0 表示假）

■ 若条件为真，执行循环体，执行完后回到步骤 1 再次判断

■ 若条件为假，直接跳过循环体，执行后续代码

3）死循环：

■ 一般使用 while 语句实现死循环

while (1)
{
    语句块:
}

2. do...while

○ 先执行循环体，再判断循环条件（循环体会至少执行一次）

1）基本形式：

do {
    语句块;
} while (表达式);

2）执行流程:

■ 先执行一次 do 后的循环体

■ 执行完后，判断 while 后的循环条件

□ 若条件为真（非 0），则回到 do 继续执行循环体

□ 若条件为假（0），则退出循环，执行后续代码

■ 示例

/* 输出数字 1~5 */
do {
    printf("%d ", i);          // 先执行一次：输出1
    i++;
} while (i <= 5);              // 判断i是否≤5，成立则继续循环
    // 输出结果：1 2 3 4 5

循环类型	执行逻辑	适用场景
while	先判断，后执行（可能不执行）	不确定循环是否需要执行的场景
do...while	先执行，后判断	循环体至少需要执行一次的场景

3. for 循环

1）基本形式：

for (初始化表达式; 循环条件; 循环变量更新) {
    循环体（满足条件时执行的代码）
}

2）执行流程：

■ 初始化：执行一次初始化表达式（如定义或赋值循环变量）

■ 判断条件：检查循环条件，若为真（非 0）则执行循环体，若为假（0）则退出循环

■ 更新变量：执行循环体后，执行循环变量更新操作（如自增 / 自减）

■ 重复步骤 2 和 3，直到判断条件部分为假

■ 示例

/* 输出数字 1~5 */

/* i从1开始，每次循环后+1，直到i>5时结束 */
for (int i = 1; i <= 5; i++)
{
    printf("%d ", i);
/* 判断i是否≤5，成立则继续循环 */
}
    // 输出结果：1 2 3 4 5

3）双层 for 循环：

■ 外层循环一次，里层循环一遍

for (初始化表达式1; 循环条件1; 循环变量更新1)
{
    for (初始化表达式2; 循环条件2; 循环变量更新2)
    {
        循环体（满足条件时执行的代码）;
    }
}

■ 示例

/* 使用双层for循环打印99乘法表 */
#include <stdio.h>

int main() 
    {
    // 外层循环控制行数
    for (int i = 1; i <= 9; i++) {
        // 内层循环控制每行的列数
        for (int j = 1; j <= i; j++) {
            // 打印"j × i = 乘积"，并控制格式对齐
            printf("%d×%d=%d\t", j, i, j * i);
        }
        // 每行结束后换行
        printf("\n");
    }
    return 0;
}

4. goto

○ 是一个跳转语句，用于无条件跳转到函数内的指定标签处执行代码

1）基本形式：

// 定义标签（标签名后加冒号）
标签名:
    语句;

// 在其他位置使用goto跳转
goto 标签名;

■ 示例

□ 跳转

#include <stdio.h>

int main() {
    printf("开始\n");
    
    goto end;  // 跳转到end标签处
    
    printf("这里的代码不会执行\n");  // 被跳过
    
end:  // 标签定义
    printf("结束\n");
    return 0;
}

□ 在循环中提前退出（替代多层 break）

#include <stdio.h>

int main() {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (i == 1 && j == 1) {
                goto exit_loop;  // 跳转到循环外部
            }
            printf("i=%d, j=%d\n", i, j);
        }
    }
    
exit_loop:  // 循环外的标签
    printf("已退出循环\n");
    return 0;
}

五、辅助控制语句

1. break

○ 跳出当前循环或者switch中

○ 强制终止当前所在的循环，使用break

2. continue

○ 用于跳过循环体中剩余的代码，直接进入下一次循环

○ 循环中想要屏蔽某几次循环使用continue

3. return

○ 用于终止当前函数的执行，并返回一个值给调用者

语句	作用范围	效果
break	循环（for / while）、switch	终止当前结构，跳出执行
continue	循环（for / while）	跳过当前循环剩余代码，进入下一次循环
return	函数内任意位置	终止当前函数，返回值给调用者