三、 分支和循环

目录

1. if 语句

2. 关系操作符

3. 条件操作符

4. 逻辑操作符

5. switch 语句

6. while 循环

7. for 循环

8. do-while 循环

9. break和continue语句

10. 循环的嵌套

11. goto语句

1. if 语句

在C语言中，"if"语句的基本结构也是类似的，但是没有像Python那样的缩进来表示代码块的范围，而是使用花括号 {} 来标记代码块。

基本的C语言中的"if"语句结构如下：

if (condition) {
    // 如果条件为真，则执行这里的代码块
} else {
    // 如果条件为假，则执行这里的代码块
}

在这个结构中，condition 是一个条件表达式，如果它为真，则执行花括号内的第一个代码块；否则，执行**else**语句后面的花括号内的代码块。

2. 关系操作符

关系操作符（Relational Operators）是编程中用于比较两个值之间关系的运算符。这些操作符通常用于条件语句（如"if"语句）或表达式中，以确定是否满足特定条件。

在大多数编程语言中，常见的关系操作符包括：

1. 等于（Equal to）：
   • 表示为 ==，用于检查两个值是否相等。
2. 不等于（Not equal to）：
   • 表示为 !=，用于检查两个值是否不相等。
3. 大于（Greater than）：
   • 表示为 >，用于检查一个值是否大于另一个值。
4. 小于（Less than）：
   • 表示为 <，用于检查一个值是否小于另一个值。
5. 大于等于（Greater than or equal to）：
   • 表示为 >=，用于检查一个值是否大于或等于另一个值。
6. 小于等于（Less than or equal to）：
   • 表示为 <=，用于检查一个值是否小于或等于另一个值。

这些关系操作符通常用于比较数值类型（如整数、浮点数）或字符类型的数据。它们返回的结果通常是布尔值（真或假），用于控制程序的流程或决定表达式的结果。

3. 条件操作符

条件操作符（Conditional Operator），也称为三元运算符，是一种在大多数编程语言中可用的简洁的条件表达式。它允许在单行代码中根据条件选择两个不同的值。

条件操作符的基本语法如下：

condition ? value_if_true : value_if_false

在这个结构中，condition 是一个布尔表达式，如果它为真，则返回 value_if_true；否则返回 value_if_false。

4. 逻辑操作符

逻辑操作符（Logical Operators）用于组合和改变布尔值的逻辑关系。常见的逻辑操作符包括：

1. 与（AND）：
   • 表示为 &&，当且仅当两个操作数都为真时结果为真，否则为假。
2. 或（OR）：
   • 表示为 ||，当至少一个操作数为真时结果为真，如果两个操作数都为假，则结果为假。
3. 非（NOT）：
   • 表示为 !，用于取反操作数的值，即如果操作数为真，则结果为假；如果操作数为假，则结果为真。

这些逻辑操作符通常用于布尔表达式中，以便在程序中执行条件化的逻辑操作。

举例来说，在C语言中，你可以使用逻辑操作符来组合布尔表达式：

#include <stdio.h>int main() {
    int x = 5, y = 10, z = 15;

    // 如果 x 大于 0 并且 y 大于 0，则输出 "x 和 y 都是正数"
    if (x > 0 && y > 0) {
        printf("x 和 y 都是正数\\n");
    }

    // 如果 x 大于 0 或者 z 大于 0，则输出 "x 或者 z 至少有一个是正数"
    if (x > 0 || z > 0) {
        printf("x 或者 z 至少有一个是正数\\n");
    }

    // 如果 y 不等于 0，则输出 "y 不是零"
    if (! (y == 0)) {
        printf("y 不是零\\n");
    }

    return 0;
}

这段代码会输出：

x 和 y 都是正数
x 或者 z 至少有一个是正数
y 不是零

因为 x 和 y 都是正数，x 或者 z 至少有一个是正数，以及 y 不是零。

5. switch 语句

**switch语句是一种流程控制语句，用于根据一个表达式的值在多个可能的情况中选择执行不同的代码块。它是一种比多个嵌套的if**语句更简洁的方法，特别适用于需要对同一个变量进行多重比较的情况。

**switch**语句通常的结构如下：

switch (expression) {
    case constant1:
        // 如果 expression 等于 constant1，则执行这里的代码
        break;
    case constant2:
        // 如果 expression 等于 constant2，则执行这里的代码
        break;
    // 可以有更多的 case 分支
    default:
        // 如果 expression 与任何 case 都不匹配，则执行这里的代码
}

在这个结构中，expression 是一个表达式，它的值会被逐个与**case后面的常量进行比较。如果expression的值等于某个case后面的常量值，则执行对应的代码块。break语句用于终止switch语句的执行，如果省略了break，则会继续执行下一个case中的代码块。default是可选的，用于指定当expression的值与任何case**都不匹配时要执行的代码块。

以下是一个示例，展示了如何使用**switch**语句根据星期几打印相应的名称：

#include <stdio.h>int main() {
    int day = 4;

    switch (day) {
        case 1:
            printf("星期一\\n");
            break;
        case 2:
            printf("星期二\\n");
            break;
        case 3:
            printf("星期三\\n");
            break;
        case 4:
            printf("星期四\\n");
            break;
        case 5:
            printf("星期五\\n");
            break;
        case 6:
            printf("星期六\\n");
            break;
        case 7:
            printf("星期日\\n");
            break;
        default:
            printf("错误的日期\\n");
    }

    return 0;
}

在这个示例中，**day**的值是4，所以程序会输出"星期四"。

6. while 循环

**while循环是一种常见的迭代控制结构，它会重复执行一个代码块，直到给定的条件不再满足为止。while**循环在进入循环体之前会首先检查条件，如果条件为真，则执行循环体内的代码块；否则，退出循环。

**while**循环的基本语法如下：

while (condition) {
    // 循环体内的代码
    // 这部分代码会在每次循环迭代时执行
}

在这个结构中，condition 是一个布尔表达式，它决定了是否继续循环。只要**condition为真，循环体内的代码就会被执行，直到condition**为假时，循环结束。

以下是一个示例，展示了如何使用**while**循环来计算从1到10的整数之和：

#include <stdio.h>int main() {
    int sum = 0;
    int i = 1;

    while (i <= 10) {
        sum += i;
        i++;
    }

    printf("从1到10的整数之和为：%d\\n", sum);

    return 0;
}

在这个示例中，循环从**i的值为1开始，每次迭代将i加到sum中，然后递增i的值。循环继续进行，直到i**的值大于10时，循环结束。最终，程序会输出从1到10的整数之和。

7. for 循环

**for循环是一种常用的迭代控制结构，它允许你在一个有限的范围内重复执行代码块。for**循环通常用于遍历数组或执行已知次数的迭代操作。

**for**循环的基本语法如下：

for (initialization; condition; update) {
    // 循环体内的代码
    // 这部分代码会在每次循环迭代时执行
}

在这个结构中：

• initialization 用于初始化循环控制变量，通常是一个赋值表达式，它只在循环开始时执行一次。
• condition 是循环继续执行的条件，只要条件为真，循环就会继续执行；一旦条件为假，循环就会结束。
• update 用于更新循环控制变量的值，在每次循环迭代结束时执行，通常是一个递增或递减操作。

以下是一个示例，展示了如何使用**for**循环来计算从1到10的整数之和：

#include <stdio.h>int main() {
    int sum = 0;

    // 循环从 i = 1 开始，每次循环递增 i，直到 i = 10 为止
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }

    printf("从1到10的整数之和为：%d\\n", sum);

    return 0;
}

在这个示例中，**for循环在i的值从1逐渐增加到10的过程中，重复执行循环体内的代码块，将每个i的值加到sum**中。最终，程序会输出从1到10的整数之和。

8. do-while 循环

**do-while循环是一种迭代控制结构，类似于while循环，不同之处在于do-while**循环保证循环体至少执行一次，然后在每次迭代之前检查条件是否为真。

**do-while**循环的基本语法如下：

do {
    // 循环体内的代码
    // 这部分代码会在每次循环迭代时执行
} while (condition);

在这个结构中：

• 循环体内的代码会在条件被检查之前至少执行一次。
• condition 是一个布尔表达式，用于判断是否继续循环。如果条件为真，循环将继续执行；如果条件为假，则循环结束。

以下是一个示例，展示了如何使用**do-while**循环来提示用户输入密码，直到输入正确为止：

#include <stdio.h>#include <string.h>int main() {
    char password[] = "password123";
    char input[20];

    do {
        printf("请输入密码：");
        scanf("%s", input);
    } while (strcmp(password, input) != 0);

    printf("密码正确，登录成功！\\n");

    return 0;
}

在这个示例中，循环首先执行一次循环体，然后检查用户输入的密码是否正确。如果密码不正确，循环将继续提示用户输入密码，直到输入正确为止。

9. break和continue语句

break和continue是两种用于控制循环执行流程的关键字，通常用于for、while、**do-while**等循环语句中。

1. break语句：

   • **break语句用于跳出当前所在的循环，无论循环条件是否为真。一旦执行到break**语句，程序将立即跳出当前循环，并执行循环后面的代码。

   for (int i = 0; i < 10; i++) {
       if (i == 5) {
           break; // 当 i 等于 5 时跳出循环
       }
       printf("%d\\n", i);
   }
   

   在这个例子中，当**i的值等于5时，break**语句被执行，循环立即终止，不再继续执行后续的迭代。

2. continue语句：

   • **continue语句用于跳过当前迭代中剩余的代码，立即开始下一次迭代。执行continue**语句后，循环条件会被重新检查。

   for (int i = 0; i < 10; i++) {
       if (i % 2 == 0) {
           continue; // 当 i 是偶数时跳过当前迭代
       }
       printf("%d\\n", i);
   }
   

   在这个例子中，如果**i是偶数，continue语句会导致程序跳过printf**语句，直接进行下一次迭代。因此，只有奇数会被打印出来。

**break和continue**语句通常与条件语句一起使用，以在循环中实现更灵活的控制流程。

10. 循环的嵌套

循环的嵌套是指在一个循环内部包含另一个或多个循环的情况。通过循环的嵌套，可以实现更复杂的迭代和控制流程。

循环的嵌套可以是任意级别的，也就是说，你可以在一个循环内部放置另一个循环，而内部的循环又可以包含其他循环，依此类推。

下面是一个简单的示例，展示了使用嵌套循环来打印一个九九乘法表：

#include <stdio.h>int main() {
    for (int i = 1; i <= 9; i++) {
        for (int j = 1; j <= i; j++) {
            printf("%d * %d = %d\\t", j, i, i * j);
        }
        printf("\\n");
    }
    return 0;
}

在这个示例中，外部的**for循环用于控制九九乘法表的行数，内部的for**循环用于控制每行中的列数。内部循环的迭代次数随着外部循环的迭代而增加，以形成九九乘法表的规律排列。

循环的嵌套可以让你处理更复杂的情况，例如在二维数组中进行搜索、处理图形或执行其他需要多层迭代的操作。但需要注意，过多的循环嵌套可能会使代码变得难以理解和维护，因此在设计时需要谨慎考虑。

11. goto语句

goto语句是一种在程序中实现无条件跳转的控制语句。使用goto语句，你可以直接跳转到程序中的指定标签（label）处执行代码。

goto语句的基本语法如下：

goto label;

label:
    // 这里是标签处的代码

在这个结构中，label是一个标签，它是一个标识符，后面紧跟着一个冒号 :。goto语句会跳转到指定标签处执行代码。当程序执行到goto语句时，会直接跳转到对应的标签处执行代码，继续执行标签处的代码，直到遇到程序结束或另一个goto语句。

下面是一个简单的示例，展示了如何使用goto语句实现循环：

#include <stdio.h>
int main() {
    int i = 0;

loop:
    if (i < 5) {
        printf("%d ", i);
        i++;
        goto loop;
    }

    return 0;
}

在这个示例中，程序从标签loop处开始执行，如果i小于5，则输出i的值并递增i，然后跳转回标签loop处继续执行。这样就实现了一个简单的循环。

虽然goto语句在某些情况下可以提供便利，但它也容易导致代码变得难以理解和维护，因此应该避免滥用goto语句，尽量使用更结构化的控制语句来实现相同的功能。