从零接触C语言(初览)-V: 条件和循环

TIP
如果你从未接触过 C 语言, 那么我建议你先阅读前面的文章:
📌 从零开始接触 C 语言

语句#

C 语言中, 语句是程序执行的基本单元, 以;结尾

前面的文章中, 已经遇见过最基础两种句式的:

表达式语句:

1
age = 20;
2
age1 + age2;
3
printf("Hello World\n");

声明语句:

1
int age;
2
int age1 = 20;                                     // 特殊的声明语句, 定义
3
char str2[] = { 'H', 'e', 'l', 'l', 'o', '\0' }; // 特殊的声明语句, 定义

除此之外, C 语言还规定有其他句式:

空语句:

1
;
2
// 只一个 ; 分号, 单独为一个语句

控制语句:

条件分支语句:

1
// if-elseif-else
2
if (a > 0) {
3
    // 其他语句
4
}
5
else if (a == 0) {
6
    // 其他语句
7
}
8
else {
9
    // 其他语句
10
}
11

12
// switch-case
13
switch (a) {
14
case 0:
15
    // 其他语句
16
    break;
17
case 1:
18
    break;
19
default:
20
    break;
21
}

循环语句:

1
// for 循环
2
for (i = 0; i < 10; i = i + 1) {
3
    // 其他语句
4
}
5

6
// while 循环
7
while (true) {
8
    // 其他语句
9
}
10

11
// do-while 循环
12
do {
13
    // 其他语句
14
} while (true);

跳转语句:

1
break; // 直接结束循环、switch-case
2

3
continue; // 直接跳过当前循环, 进入下一轮循环
4

5
goto label; // 跳转到 label标签语句处
6

7
return; // 从函数中返回

标签语句:

1
label:
2
    // 其他语句
3
// 用于 goto 跳转

本片文章要重点介绍的是控制语句中的条件分支和循环语句

条件分支语句#

条件分支语句, 是根据条件来选择执行分支的语句

什么是根据条件来选择执行分支呢?

意思是, 满足哪个条件, 就执行哪个条件对应的分支, 更书面一点表述: 哪个条件为真, 则执行此条件对应的分支

C 语言中有两种条件分支语句“if-else if-else和switch-case`

但在具体介绍这两种条件分支语句之前, 还先要了解 C 语言中的条件是什么, 条件的满足是怎么样判断的? 即, 如何判断条件的真假

条件与条件的真假#

C 语言提供有关系运算符和逻辑运算符来实现条件的判断:

关系运算符:

符号	使用	功能
`==`	`a == b`	判断`a`和`b`是否相等
`!=`	`a != b`	判断`a`和`b`是否不相等
`>`	`a > b`	判断`a`是否大于`b`
`<`	`a < b`	判断`a`是否小于`b`
`>=`	`a >= b`	判断`a`是否大于等于`b`
`<=`	`a <= b`	判断`a`是否小于等于`b`

关系运算符, 用于判断变量或常量之间的关系是否成立, 成立则为真, 不成立则为假

逻辑运算符

符号	使用	功能
`&&(逻辑与)`	`表达式1 && 表达式2`	两个表达式必须全为真, 此表达式才为真
`\|\|(逻辑或)`	`表达式1 \|\| 表达式2`	两个表达式只要有一个为真, 此表达式为真
`!(逻辑非)`	`! 表达式`	根据所作用表达式的真假, 转换真假

逻辑运算符, 用于组成复杂逻辑的条件判断表达式, 作用于其他表达式

需要额外说明的是:

&&(逻辑与)运算符, 只有左边的表达式为真时, 才会执行右边的表达式进行判断
||(逻辑或)运算符, 如果左边的表达式为真, 右边的表达式将不会被执行

这两个性质非常的重要

C 语言提供了这么多运算符用于条件和逻辑判断, 实际上表达式的真假却很简单

C 语言中, 表达式为非零值(正数或负数)时即为真, 表达式为 0 时即为假

并且, C 语言中, 当条件表达式为真时, 此表达式的值为 1, 为假时, 此表达式的值为 0

1
#include <stdio.h>
2

3
int main() {
4
    printf("10 > 0: %d\n", 10 > 0);
5
    printf("10 < 0: %d\n", 10 < 0);
6

7
    return 0;
8
}

`if-elseif-else`#

if条件分支的语法是这样的:

1
/* 单分支 */
2
if (条件) {
3
    // 条件满足 会执行此分支
4
}
5

6
/* 双分支 */
7
if (条件) {
8
    // 条件满足 会执行此分支
9
}
10
else {
11
    // 条件不满足 会执行此分支
12
}
13

14
/* 多分支 */
15
if (条件1) {
16
    // 条件1 对应的分支
17
}
18
else if (条件2) {
19
    // 条件2 对应的分支
20
}
21
else if (条件3) {
22
    // 条件3 对应的分支
23
}
24
else if (条件n) {
25
    // 条件n 对应的分支
26
}
27
else {
28
    // 如果以上条件 都不满足, 会执行的分支
29
}

if条件分支的使用很简单, 但需要注意:

同一个条件语句块中, 条件分支是从上到下依次判断的, 且每一个条件分支的执行是互斥的, 即使存在多个条件满足的情况, 也只会执行第一个条件满足的分支

以代码为例:

1
#include <stdio.h>
2

3
int main() {
4
    int num = 10;
5
    if (num < 0) {
6
        printf("num < 0, num: %d\n", num);
7
    }
8
    else if (num > 0) {
9
        printf("num > 0, num: %d\n", num);
10
    }
11
    else if (num == 10) {
12
        printf("num == 10\n");
13
    }
14
    else if (num > 10) {
15
        printf("num > 10, num: %d\n", num);
16
    }
17
    else {
18
        printf("num == 0\n");
19
    }
20

21
    return 0;
22
}

这段代码的执行结果为:

虽然num = 10同时满足了num > 0和num == 10两个条件

但是, 只执行了num > 0条件的分支, 可以证明各分支之间的执行是互斥的

`switch-case`#

switch条件分支的语法是这样的:

1
switch (整型值) {
2
case 0:
3
    // 分支内容
4
    break;
5
case 1:
6
    // 分支内容
7
    break;
8
default:
9
    // 分支内容
10
    break;
11
}

if条件分支的使用比较灵活, 可以用于任何的条件表达式

而switch不同, switch则只用于整型值是否与特定值相等的判断, 即 switch ()的括号中只能是整型值

switch (整型值)括号中的整型值, 是与case 整型值中的整型值做相等判断的

如果相等, 则执行对应的分支; 如果不相等, 就不执行

如果switch中的整型值与所有case后的整型值均不相等, 且default分支存在, 则会去执行default分支

下面以代码为例:

1
#include <stdio.h>
2

3
int main() {
4
    int num = 3;
5
    switch (num) {
6
    case 0:
7
        printf("num : 0\n");
8
        break;
9
    case 1:
10
        printf("num : 1\n");
11
        break;
12
    case 2:
13
        printf("num : 2\n");
14
        break;
15
    case 3:
16
        printf("num : 3\n");
17
        break;
18
    default:
19
        printf("default num : %d\n", num);
20
        break;
21
    }
22

23
    return 0;
24
}

可以看到, num = 3就执行了switch (num)-case 3的分支

switch正确的使用并不复杂, 不过有几个点需要特别注意一下:

switch括号中只能是一个整型值, 不支持其他类型的数据
case后的整型值必须是整型常量, 且在同一个switch条件分支必须唯一

break;通常是必须的, 通常用于执行完匹配的case分支后跳出整个switch结构

如果不使用break;, 程序会继续执行后续的case分支, 直到遇到break;或switch结束

这个现象被称为case穿透

以代码为例:

1
#include <stdio.h>
2

3
int main() {
4
    int num = 1;
5
    switch (num) {
6
    case 0:
7
        printf("num : 0\n");
8
    case 1:
9
        printf("num : 1\n");
10
    case 2:
11
        printf("num : 2\n");
12
    case 3:
13
        printf("num : 3\n");
14
    default:
15
        printf("default num : %d\n", num);
16
        break;
17
    }
18

19
    return 0;
20
}

这段代码的执行结果是:

可以看到, 在匹配到case 1之后, 在遇到break;或switch结束之前, 按顺序执行了之间的所有case分支

NOTE
break;关键词只能在switch和循环语句中使用, 作用是跳出所处结构

循环语句#

从字面意思理解, 循环语句可以实现语句的循环执行

事实也确实如此

C 语言中, 循环语句有三种for循环 while循环和do-while 循环

`for`循环#

for循环的语法是这样的:

1
for (part1; part2; part3) {
2
    // 循环体, 即 要循环执行的内容
3
}

首先, 比较容易理解的是循环体, 循环体就是需要循环执行的语句, 没有额外的语法限制

然后就是for (part1; part2; part3)的三个part:

part1, 是开始循环之前会自动执行一次的语句

即, 首次循环之前, 会首先自动执行一次且仅执行一次的语句, 通常用于循环控制变量的初始化
part2, 是循环继续执行的条件表达式

如果, part2这个表达式为真, 循环就继续执行

如果, part2这个表达式为加, 循环就结束
part3, 是每次循环结束之后, 会自动执行的语句

part3的语句, 在每次for循环完成之后, 都会执行一次

通常用于修改循环控制变量, 以控制for循环结束

用代码最方便理解:

1
#include <stdio.h>
2

3
int main() {
4
    for (int index = 0; index < 5; index = index + 1) {
5
        printf("the index: %d\n", index);
6
    }
7

8
    return 0;
9
}

可以看到, 循环体一共执行了5次

从int index = 0(part1)开始, 每次执行循环体之后, 执行index = index + 1(part3), 直到index = 5时, 不满足index < 5(part2)循环结束

`while`循环#

while循环的语法是这样的:

1
while (条件) {
2
    // 循环体
3
}

while循环相对比较简单, 只要条件成立, 循环体就执行

需要注意的时, 循环控制变量要在while循环之前就定义好, 循环控制操作通常在循环体内执行

举个简单的例子:

1
#include <stdio.h>
2

3
int main() {
4
    int index = 0;
5
    while (index < 5) {
6
        printf("the index: %d\n", index);
7
        index = index + 1;
8
    }
9

10
    return 0;
11
}

执行结果为:

与上面for循环的例子执行结果是一样的

实际上, 这两个例子(for和while循环的例子)可以看作是等价的

`do-while`循环#

do-while循环与while循环很相似, 语法是这样的:

1
do {
2
    // 循环体
3
} while (条件);

与while循环相同, do-while循环, 只要条件为真, 循环就继续执行

与while循环不同的是, do-while循环总是先执行一次循环体, 之后再进行条件判断

同样举一个简单的例子:

1
#include <stdio.h>
2

3
int main() {
4
    int index = 1;
5
    do {
6
        printf("the index: %d\n", index);
7
    } while (index < 1);
8

9
    return 0;
10
}

这段代码的执行结果为:

可以看到, 即使index初始值为 1, 且do-while循环中的条件是index < 1, 循环体依旧执行了一次

这可以说明, do-while循环确实总是先执行一次循环体, 之后再进行条件判断

语句#

条件分支语句#

条件 与 条件的真假#

if-elseif-else#

switch-case#

循环语句#

for循环#

while循环#

do-while循环#

条件与条件的真假#

`if-elseif-else`#

`switch-case`#

`for`循环#

`while`循环#

`do-while`循环#