“你才25岁，你可以成为任何你想成为的人.”

大家好，我是anduin，没错我回来了。由于考试的缘故，导致鸽了很久，从今天开始，我会带大家一起继续学习C语言。今天带来的内容是分支和循环语句的知识点部分，话不多说，我们这就开始。如有错误，还请多多指正。

1. 什么是语句？

C语言中可分为以下五类:

1. 表达式语句
2. 函数调用语句
3. 控制语句
4. 复合语句
5. 空语句

而在这一部分我们着重介绍的是控制语句：
控制语句是用于控制程序的执行流程，以实现程序的各种结构方式，他们有特定的语句定义符组成。
对其进行分类：

1. 分支语句（条件判断语句）：if语句、switch语句；
2. 循环语句：while语句、for语句、do while语句；
3. 转向语句：break语句、continue语句、return语句、goto语句

2. 分支语句

在初识C语言中，我们初步了解过分支语句，接下来我们对其内容进行逐步讲解。

2.1 if语句

2.1.1语法结构

if语句的语法结构可以分为单分支、双分支和多分支，随着分支数的增加，对于内容的筛选也更加严格。

//单分支
if(表达式)
    语句;
---------
//双分支
if(表达式)
    语句1;
else
    语句2;
---------
//多分支
if(表达式1)
    语句1;
else if(表达式2)
    语句2;
else
    语句3;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.1.2 样例

#include<stdio.h>
int main()
{
    int score = 0;
    scanf("%d", &score);
    if(score<60)
        printf("不及格\n");
    else if (score >= 60 && score < 70)
        printf("及格\n");
    else if (score >= 70 && score < 85)
        printf("良好\n");
    else
        printf("优秀\n");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果：

分析：当我们相对考试成绩做一个较为细致的划分，我们可以使用多分支，当输入成绩后，当数据符合条件时，这个语句就会被执行，一旦符合了一个条件，那么这个分支语句中其他的部分就不会被执行，例如输入89，那么不符合条件的语句就不会被执行，会直接执行else后所对应的语句。
我们不难看出随着分支的增加，这个语句所具有的功能所可以判定的条件也会增加。

2.1.3 常见误区

1. 表达式书写

if/else if后的条件可千万不能写成60<=score<70的形式，这个表达式的执行顺序为先执行60<=score这个表达式，例如我们输入59，那么这个表达式就会执行，结果为假，这个表达式就变成了0<70，为真，就会执行对应语句，但是59是并不符合条件的，这就与我们的初衷背道而驰了，所对于数学上的一些思想并不完全适用于C语言中。

2. 执行多语句

在分支语句的某一个条件中，想要输出多条语句怎么办?将其放入编译器中看看：

分析：在后面直接加上想要执行的语句，发现报错了，原因是分支语句默认只执行一条语句；

如果想要执行多条语句，那么可以用如下方法：

int main()
{
    int score = 0;
    scanf("%d", &score);
    if (score < 60)
    {
        printf("不及格\n");
        printf("请继续努力\n");
    }
    else
        printf("及格\n");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

如果条件成立，要执行多条语句，应该使用代码块，一对{ }就是一个代码块。

3.悬空else

#include <stdio.h>
int main()
{
    int a = 0;
    int b = 2;
    if(a == 1)
        if(b == 2)
            printf("hehe\n");
    	else
        printf("haha\n");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

这个代码的结果是什么？让我们测试一下：

答案出乎意料，是空语句这是什么原因呢？

分析：首先我们可以看到一个变化，当我们把代码复制到编译器中，它的对齐发生了改变。在分支语句中，else匹配符合就近原则，默认与靠近的if进行匹配，那么这个if和else就是第一个if的子语句，第一个条件判断都没通过，那么还谈什么执行后面的分支语句呢？
所以该代码的结果为空。
所以养成良好的编码风格尤其重要，我们可以写成这样让别人能读懂，读明白，让代码更加优美：

#include <stdio.h>
int main()
{
    int a = 0;
    int b = 2;
    if(a == 1)
    {
        if(b == 2)
            printf("hehe\n");
        else
            printf("haha\n");                    
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Tips:对于第一段代码，可能大家会有疑惑，if后面不是默认执行一条语句吗，这里是不是多条语句呢？这里其实是一条语句，因为这段代码不是执行if就是执行else，本质还是一条语句。(这也说明了if…else语句可以嵌套使用）。

2.1.4 良好的if书写形式

层次分明：在每个分支后都习惯性用代码块来包括语句，使代码可读性高，清晰明了。

if(condition)
{
    return x;
}
else
{
    return y;
}
1
2
3
4
5
6
7
8

常量左置：习惯性地将常量写在左边，避免判断(==)写成赋值(=)而引起的错误，让代码及时报错，形成严谨的风格。

int num = 1;
if(5 == num)
{
    printf("anduin\n");
}
1
2
3
4
5

2.2 switch语句

2.2.1语法结构

switch(整形表达式)
{
    语句项;
    //case 整形常量表达式:
        //语句；
}
1
2
3
4
5
6

当接收的数据和case后的整形常量表达式相匹配时，就会执行对应的语句。
warning:表达式必须为整形。

2.2.2 样例

#include <stdio.h>
int main()
{
	int day = 0;
    scanf("%d", &day);
	switch (day)
	{
		case 1:
			printf("星期一\n");
		case 2:
			printf("星期二\n");
		case 3:
			printf("星期三\n");
		case 4:
			printf("星期四\n");
		case 5:
			printf("星期五\n");
		case 6:
			printf("星期六\n");
		case 7:
			printf("星期天\n");
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

让我们看一下实际效果：

代码并没有达到我们想实现的效果，这是为什么？因为它没有固定的出口，他只能一直执行，直到结束，这时就有必要了解一下break语句。

2.2.3 break语句

switch语句中，整形表达式的值只决定从哪里进入语句，并不会规定从哪里跳出语句，这时我们可以用break语句来跳出整个switch语句，例如：

#include <stdio.h>
int main()
{
	int day = 0;
	scanf("%d", &day);
	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");
           break;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

运行结果：

总的来说就是case决定入口，break决定出口。

2.2.4 default子句

如果表达式的值和所有的case标签的值都不匹配怎么办？所有的语句会被跳过，输出空语句。

这时我们可以用上段代码中出现的default子句来解决。

让我们测试一下：

我们达到了预期结果。

default子句可以写在任意case标签可以出现的位置，简单来说，就算写在开头位置也可以。

当switch表达式的值不匹配所有的case标签的值时，default子句后面的语句就会执行，每个语句只能出现一条default子句。

这里anduin建议大家习惯性地把default子句写在语句末尾处且最好在子句结尾加上break，

设想一下，如果default子句被写在了开头，但是他没有加break，那么结果会如何？

运行结果：

这并不是我们想得出的结果，所以考虑美观和准确性，我还是比较倾向于写在语句的末尾处。

总的来说default子句的存在不是必须的，但是是一个锦上添花的存在。

2.2.5 小试牛刀

下列程序输出结果是什么？

#include <stdio.h>
int main()
{
	int n = 1;
	int m = 2;
	switch (n)
	{
	case 1:
		m++;
	case 2:
		n++;
	case 3:
		switch (n)
		{//switch允许嵌套使用
		case 1:
			n++;
		case 2:
			m++;
			n++;
			break;
		}
	case 4:
		m++;
		break;
	default:
		break;
	}
	printf("m = %d, n = %d\n", m, n);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

分析：这里用到了switch的嵌套，n为1，那么就从case 1进入语句，由于break并不存在，所以依次往下执行，当到达case 3时，m = 3,n = 2，进入case 3所包含的switch语句，执行case 2，m,n进行自增后结束此开关语句，随后进入case 4，此时m = 4,n = 3，最后经过case 4后跳出循环，此时打印的值为m = 5,n = 3.

2.3 一句话总结

分支少，条件连续用if…else语句；分支多，条件层次多，且表达式为整形，用switch语句。

3. 循环语句

3.1 while循环

3.1.1 语法结构

while(表达式)
    循环语句;
1
2

while后的表达式结果为真，那么就进入循环语句，循环语句执行后继续判断真假，然后往复，当表达式结果为假，那么就结束循环。

3.1.2 样例

实现打印1-10：

#include<stdio.h>
int main()
{
    int i = 1;
    while(i <= 10)
    {
        printf("%d ", i);
        i++;//自增条件    
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11

运行结果：

注意这段代码i++必不可少，由于表达式恒<=10，所以一直为真，那么就会一直循环，可不敢丢这个条件啊。

3.1.3 while循环的break和continue

1.break语句

#include<stdio.h>
int main()
{
	int i = 1;
	while (i <= 10)
	{
		if (5 == i)
			break;
		printf("%d ", i);
		i++;
	}
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在循环中只要遇到break，就停止后期的所有的循环，直接终止循环。

while中的break是用于永久终止循环的。

在这里当i = 5时，遇到了break循环就被终止了，因此只打印1 2 3 4

2.continue语句

#include<stdio.h>
int main()
{
	int i = 1;
	while (i <= 10)
	{
		if (5 == i)
			continue;
		printf("%d ", i);
		i++;
	}
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

运行结果：

乍一看好像没什么问题，但是这个程序并没有结束，它陷入了死循环，为什么？

continue适用于终止本次循环的，也就是continue后的代码不会被执行，直接跳转到while语句的判断部分，进行下一次循环的入口判断。

这里continue当i = 5时跳过本次循环，然后重新回到判断条件i<=10处，然后再跳出循环往复，形成了死循环。

3.2 for循环

我们自己观察不难发现while循环中具有着三个必须条件，就拿上段代码来说，int i = 1(初始化部分),i<=10(判断部分),i++(调整部分)，由于while循环的风格，三者偏离较远，调整代码时有一定的困难。

而for循环完美解决了这个缺点,for循环的条件相对集中，使用效率也比较高。

3.2.1 语法结构

for( 表达式1; 表达式2; 表达式3)
    循环语句;
1
2

表达式1

表达式1为初始化部分，用于初始化循环变量的。

表达式2

表达式2为条件判断部分，用于判断循环什么时候终止。

表达式3

表达式3为调整部分，用于循环结构的调整。

3.2.2 样例

依然实现打印1-10：

#include<stdio.h>
int main()
{
    int i = 0;
    for(int i = 1; i <= 10; i++)
    {
        printf("%d ", i);    
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10

首先会执行i=1，然后判断条件是否成立，成立则进入循环体，再i++，再进行判断，再执行，在++，直到判断条件不成立，随后终止循环。

3.2.3 for循环的break和continue

1.break

#include<stdio.h>
int main()
{
    int i = 0;
    for(int i = 1; i <= 10; i++)
    {
        if(5 == i)
            break;
            //continue;
        printf("%d ", i);    
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

运行结果：

和while循环中相同，当执行遇到break时，会终止循环。

2. continue

运行结果：

和while循环的continue的结果有所不同，但原理还是相同的，continue是终止本次循环，那么continue后的语句就不执行了，由于这里的调整语句并不在continue下方，所以会直接i++在进行判断，只不过跳过了i = =5这个状况了。

3.2.4 对于for循环的一些建议

建议1

不可在for循环中修改循环变量，防止for循环失去控制

#include<stdio.h>
int main()
{
    int i = 0;
    for(int i = 1; i <= 10; )
    {
        if(5 == i)
            continue;
        printf("%d ", i);
        i++;    
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

例如随意改变调整部分的位置，从而导致原本能实现的功能没实现。

原本可以打印1 2 3 4 6 7 8 9 10的代码，被弄成了死循环。

这不是自找麻烦吗？

for循环规定它是怎么样的，就按照规定写，不要另辟蹊径，以主流为准。

建议2

采用前闭后开的写法

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	for (i = 0; i < 10; i++)//前闭后开
	{
		printf("%d ", arr[i]);
	}
}
1
2
3
4
5
6
7
8
9
10

相当于[ 0 , 10)的写法，至于这样写的原因，是因为我们大多数时候用这种写法可以明确地看出这个循环执行次数，例如10 - 0，我们很明确的可以看出这个循环执行十次，但是对于其他情况下左闭右闭的方法会更为合适，就是看需求！

3.2.5 小试牛刀

下列程序循环次数为几次？

#include<stdio.h>
int main()
{
	int i = 0;
	int k = 0;
	for(i = 0, k = 0; k = 0; i++, k++)
		k++;
	return 0;
}
1
2
3
4
5
6
7
8
9

条件判断部分：k = 0是一个赋值，每次都把k赋值为0，表达式结果为0，结果为假，循环次数为0次。

3.3 do…while()循环

3.3.1 语法结构

do…while循环由于其结构，至少会执行一次。
也正因为其特性，所以应用场景较少。

do
	循环语句;
while(表达式);
1
2
3

3.3.2 样例

实现打印1-10：

#include<stdio.h>
int main()
{
	int i = 1;
	//1-10
	do
	{
		printf("%d ",i);
		i++;
	}while(i<=10);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

3.3.3 do…while循环的break和continue

1.break

#include<stdio.h>
int main()
{
	int i = 1;
	//1-10
	do
	{
		if(5 == i)
			break;
			//continue;
		printf("%d ",i);
		i++;
	}while(i<=10);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

break终止循环，打印结果为1 2 3 4

2.continue

continue打印1 2 3 4,i此时等于5，continue跳过本次循环，i没有进行自增，而是直接跳转到条件判断部分，条件恒成立，于是死循环。

3.4 一句话总结

循环语句各有优势，在使用循环时要再三思考，哪个比较契合题目，用最优的方法，得出最优的结果。

4. goto语句

goto语句是一个不常使用的语句。

goto运用不当可能会带来许多麻烦，但是合理的使用goto语句，可以达到预想不到的结果。

4.1 语法结构

goto语句也称为无条件转移语句，其一般格式如下：

语句标号:
	goto 语句标号;
1
2

我们可以把语句标号看作一个传送门，每遇到语句标号就会跳转到相应的语句标号处，执行语句标号下的语句,遇到语句标号时继续跳转，循环往复…

4.2 样例

#include<stdio.h>
int main
{
again:
    printf("hello anduin\n");
    goto again;
    return 0;
}
1
2
3
4
5
6
7
8

看这个例子,again就是所谓的语句标号，当程序运行时，首先打印，然后跳转到相应的语句标号，也就是在打印上方的again处，继续打印，这个程序就是来回打印"hello anduin"这句话，也可以看做一个死循环。

既然是循环，那么可以写成循环的形式，所以goto语句是可以用别的方式实现的。

4.3 goto语句的缺点

• goto语句可能会使代码可读性降低，毕竟传送门可以随处存在
• goto不能跨函数使用。只能在本函数内使用，应用范围小
• goto语句可以被其他方式实现，不可替代性低

4.3 goto语句的优点

大家可能觉得goto语句副作用这么多，它还有存在的必要嘛，要知道每个语句都是有它的优点的,goto语句也不例外。

goto语句在处理跳出多层嵌套循环时，具有着巨大的优势。

比如碰到一个多重嵌套的循环，我们在循环过后依然需要执行相关代码，不能退出函数，但是用break有需要用很多层，过程繁琐。

这时，使用goto语句，让这些问题都迎刃而解。

样例：

for(...)
{
    for(...)
	{
		for(...)
		{
			if(disaster)
				break;
		}
        break;
	}
    break;
}
…
	if(disaster)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

看如下情况，单单跳出循环就使用了3次break，是不是过于繁琐了？

我们看看用goto如何解决：

for(...)
{
    	for(...)
		{
			for(...)
			{
				if(disaster)
					goto error;
			}
		}
}
…
error:
if(disaster)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

一个goto，问题迎刃而解，这就是它的优点。

4.4 小试牛刀

用goto语句写一个关机小程序(只要程序运行起来，电脑在一分钟内关机，如果输入我是猪取消关机，否则强制关机)

思路：我们知道在电脑中是可以通过指令对其进行关机的，如shutdown -s -t，-s用来设置关机，-t是用来设置关机的时间，而取消关机的指令为shutdown -a。

在C语言程序中，我们可以使用system()函数来执行系统命令，从而达到关机和取消关机的目的。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
    char input[] = {0};
    system("shutdown -s -t 60");//设置关机
again:
    printf("请注意，你的电脑将在一分钟内关机，输入我是猪，就取消关机\n");
    scanf("%s", input);
    //判断
    if(strcmp(input,"我是猪")==0)
    {
        system("shutdown -a");//取消关机
    }
    else
    {
        goto again;//再给一次机会
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果：

还等什么，快去和你的好朋友分享这段能增进友谊的代码吧！(bushi)。

4.5 一句话总结

每个语句都有自己的作用，用好goto语句，使它发挥属于自己的优势。

5. 结语

以上就是分支和循环语句的知识部分，后续我会基于对这部分内容的理解，对一些题目进行讲解。

如果觉得anduin写的还不错的话，还请一键三连哦！

希望我的文章能对你有帮助，我们下篇文章见~