【C语言总集篇】分支与循环篇——从不会到会的过程

分支与循环

前言

大家好，经过前段时间的学习，我相信大家对C语言的相关知识点有了一个初步的认识了，接下来我会将前面所学的内容进行一个梳理、汇总成一个总集篇。今天是这个篇章的第一篇——分支与循环语句，今天我将用这一篇的内容讲完分支与循环语句的相关内容。

一、什么是C语言？

C语言是一门 结构化 的程序设计语言。

二、C语言有哪些结构？

在我们生活中有三种结构：

1.顺序结构：从开始一直到结束，按部就班的完成任务；

2.选择结构：开始后会面临多种情况需要进行判断，做出选择，每个选择都可能产生不同的结果；

3.循环结构：开始后会因为某些原因，需要一只重复去做一件事，除非中途出现了其它的情况不得不停止，否则会一直持续到完成某种条件才能停止。

三、语句

（一）什么是语句？

在C语言中，由一个分号";"隔开的，就是一条语句。

1.分类：

C语句可分为以下五类：

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

本篇介绍的是控制语句。

2.控制语句：

定义

用于控制程序的执行流程，以实现程序的各种结构方式，它们由特定的语句定义符组成，C语言有九种控制语句。

分类：

1.条件判断语句也叫分支语句：if语句、switch语句；

2.循环执行语句：do while语句、while语句、for语句；

3.转向语句：break语句、goto语句、continue语句、return语句。

（二）分支语句

在C语言中，选择结构的体现就是选择语句，也叫分支语句。

选择语句是指在我们做一件事情时可能会因为我们做出的决定或者行动不同而产生多种情况，如：现在我们好好读书，我们就能考上清华北大，如果我们不好好读书，我们只能去烤地瓜。

当然有时候我们的选择不一定只有两种，可能还会出现三种及以上的情况，这些都是选择。下面我们来介绍一下在计算机里是如何描述这些选择的。

if语句

1.if语句的语句结构

//if语句语法结构；
//单if语句；
if (表达式)//表达式结果为真，则执行语句，否则，不执行；
{
	语句;
}
//if ……else语句；
if (表达式)//表达式结果为真，则执行语句1；
{
	语句1;
}
else//表达式结果不为真，则执行语句2；
{
	语句2;
}
//if……else if……else多分支语句；
if (表达式1)//表达式1结果为真，则执行语句1；
{
	语句1;
}
else if (表达式2)//表达式2结果为真，则执行语句2；
{
	语句2;
}
else//表达式1/2结果都不为真，则执行语句3；（注：可以省略）
{
	语句3;
}

2.补充知识点：

（1）C语言中的真假判断

在C语言中判断真假：0为假，非0为真；

（2）在if语句中多个判断条件的书写形式

在if语句中判断对象有2个及以上的话，不能直接写为a>b>c这种形式，因为此时计算机的运行顺序是先判断啊a>b，结果为真则判断1>c，这里的1就是a>b的判断结果，结果为假，则判断0>c,这里的0就是a>b的结果，所以我们应该采用逻辑操作符来进行描述，如：a>b && b>c；

（3）变量与常量作为判断对象的书写形式

判断对象如果是变量和常量之间的判断，建议写成常量判断变量，如i == 5可以将这个表达式写成5 == i；

（4）if语句中代码块的使用

在if语句中，如果判断为真时，执行的语句只有一项，则代码块也就是大括号{}可以省略；

有多项执行语句时，需要加上代码块，如：

//单个语句需要执行；
if (condition)//condition——条件
语句1;
//多个语句需要执行；
if (condition)
{
	语句1;
	语句2;
	……
}

建议大家不管是要执行一个语句还是执行多个语句，都要加上代码块，养成良好的编码习惯；

（5）在if语句中，else遵循就近原则

这里的就近是指离else最近的且未被搭配的if进行搭配：

//else遵循就近原则
if (condition1)//在此情况下，没有对应的else与之搭配；
if (condition2)//在此情况下，下面的else与之搭配；
语句1;
else//在此情况下，else与第二个if搭配；
语句2;

这种结构叫做if嵌套，将第二个if语句嵌套在第一个if语句内，这里我们举例来进一步理解：

 这里我们可以看到，第一个else与第二个if在同一列，第二个else与第一个if在同一列，这个语句翻译过来就是：如果在满足a>b的前提下，还满足b>c，则打印min=c，如果在满足a>b的前提下不满足b>c，则打印min=b；如果不满足a>b的前提，则打印无法判断。

（6）在多分支语句中，else可以省略

//多分支语句可以省略else
//双分支语句
if (condition)
{
	语句1;
	return 0;
}
语句2;
//三分支及以上语句1
if (condition1)
{
	语句1;
	return 0;
}
else if (condition2)
{
	语句2;
	return 0;
}
语句3;
//三分支及以上语句2
if (condition1)
{
	语句1;
}
else if (condition2)
{
	语句2;
}

这里我们举几个例子分别来验证一下：

双分支语句：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>

int main()
{
	int x = 3, y = 2;
	if (x > y)
	{
		printf("max=%d\n", x);
		return 0;
	}
	printf("max=%d\n", y);
	return 0;
}

在这个代码中我们可以看到此时代码里只有if条件判断，但是在if执行语句中插入了return 0；

此时x>y正常执行if执行语句，但是我们可以看到if语句外的执行语句并未被执行；

这里我们可以看到，此时x<y，执行的是if语句外的执行语句，在这种情况下，此时的语句结构就等价于if……else，只不过是省略了else。下面我们来看看多分支语句：

多分支循环1：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>

int main()
{
	//比较三个数的大小
	int a = 2, b = 1, c = 3;
	if (a > b && b > c)
	{
		printf("max=%d\n", a);
		printf("a>b>c");
		return 0;
	}
	else if (a > c && c & b)
	{
		printf("max=%d\n", a);
		printf("a>c>b");
		return 0;
	}
	else if (b > a && a > c)
	{
		printf("max=%d\n", b);
		printf("b>a>c");
		return 0;
	}
	else if (b > c && c > a)
	{
		printf("max=%d\n", b);
		printf("b>c>a");
		return 0;
	}
	else if (c > a && a > b)
	{
		printf("max=%d\n", c);
		printf("c>a>b");
		return 0;
	}
	printf("max=%d\n", c);
	printf("c>b>a");
	return 0;
}

在这个代码中，我们看到所有的分支里都插入了return 0，同样的，最后也是没有else；

这里我们可以看到，程序正常比较三个数的大小，并且最后一种可能也没有因为省略了else而打印，下面我们再来看最后一种情况：

多分支循环2：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>

int main()
{
	//比较三个数的大小
	int a = 2, b = 1, c = 3;
	if (a > b && b > c)
	{
		printf("max=%d\n", a);
		printf("a>b>c");
	}
	else if (a > c && c & b)
	{
		printf("max=%d\n", a);
		printf("a>c>b");
	}
	else if (b > a && a > c)
	{
		printf("max=%d\n", b);
		printf("b>a>c");
	}
	else if (b > c && c > a)
	{
		printf("max=%d\n", b);
		printf("b>c>a");
	}
	else if (c > a && a > b)
	{
		printf("max=%d\n", c);
		printf("c>a>b");
	}
    else if (c > b && b > a)
    {
	printf("max=%d\n", c);
	printf("c>b>a");
    }
	return 0;
}

在这次的代码中，我们可以看到此时的分支全部通过else if进行条件判断，同样也没有else； 

此时程序正常比较3个数的大小。

现在我们来对可以省略else的情况做个总结：

1. 在多分支语句中，如果执行语句里带有转向语句如return语句，则不满足判断条件需要执行else语句时，else可以省略；
2. 在多分支语句中，在不需要用到else判断条件的情况下，可以省略else。

if语句到这里就全部介绍完了，下面我们将开始介绍第二个选择语句——switch语句。

Switch语句

switch语句也是一种分支语句，常用于多分支的情况。

在前面我们在介绍if语句时提到了多分支的if语句if……else if……else if……else，大家也能在前面的内容感受到，为了写完多分支的情况，常常会写一大堆带码，这种形式太复杂了，为了使多分支语句简单化，这时我们就得有不一样的语法形式——switch语句。

1.switch语句的语句结构

//switch语句的语句结构
switch (整型表达式)
{
	case 整型常量表达式：
		语句；
}

这里我们来用一个例子说明这个语句结构；

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	int a = 0;
	scanf("%d", &a);
	//打印一周七天的对应名称
	switch (a)
	{
	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;
}

这段代码的意思是输入一个数并将此数赋值给变量a，判断整型变量a，当a为1时打印礼拜一，当a为2时打印礼拜二……，下面我们输入2，看是否能将礼拜二打印出来：

这里我们可以看到，我们在输入2之后不仅礼拜二被打印出来了，而且礼拜三到礼拜天都被打印出来了，这并不是我们需要的结果，我们应该怎样去修改呢？

2.switch语句中的break

不知道大家对if语句中的总结还有没有印象，在多分支if语句中，如果我们想省略else，那我们应该在执行语句中加入转向语句，在if语句中我们尝试着加入了return 0，结果成功省略了else，那这里我们要加入什么呢？我就不卖关子了，在switch语句中，我们在case的执行语句中应该加入一个break——终止、停止，这样我们就能让语句的每一项分支给独立起来，如下图所示：

这里大家就可以看到，我们在输入3后，它只打印了我们需要的礼拜三，这里我们可以总结一下switch语句的完整结构：

//switch语句结构
switch (整型表达式)
{
	case 整型常量表达式：
		语句；
		break;
}

我们在使用的时候，有几种情况，那我们就可以写几种case，下面我们来试一下将1~5的结果都打印成工作日，将6~7的结果都打印成休息日，我们来编写一下代码：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	int a;
	scanf("%d", &a);
	switch (a)
	{
	case 1:
		printf("工作日");
		break;
	case 2:
		printf("工作日");
		break;
	case 3:
		printf("工作日");
		break;
	case 4:
		printf("工作日");
		break;
	case 5:
		printf("工作日");
		break;
	case 6:
		printf("休息日");
		break;
	case 7:
		printf("休息日");
		break;
	}
	return 0;
}

按照上面的格式，咱们编写出来是这样的代码，但是这时我们来思考一个问题，它们这样写与if……else if……else的写法有区别吗？前面我们也提到了switch语句是为了简化多分支语句的一种新的语法形式，但是像这样的话，并没有起到简化的作用呀。大家都有看到，在switch语句中情况1~5的执行语句是相同的，情况6~7的执行语句是相同的，那我们不妨来尝试一下将这些语句给合并起来：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	int a;
	scanf("%d", &a);
	switch (a)
	{
	case 1:
	case 2:
	case 3:
	case 4:
	case 5:
		printf("工作日");
		break;
	case 6:
	case 7:
		printf("休息日");
		break;
	}
	return 0;
}

简化之后代码就简洁了很多，此时代码的含义就变成了判断a在a为1~5的情况下打印工作日，在a为6~7的情况下打印休息日，那现在的问题来了，这样编写它能够正常运行吗？我们直接行动起来，我们先通过输入1来进行测试：

可以看到我们在输入1后成功的输出了工作日，接下来我们在输入3来进行测试：

可以看到此时输入3后，也是能够输出工作日的。下面我们输入6来进行测试：

可以看到输入6之后很好的输出了休息日，最后我们再输入7来进行测试：

从上面的测试结果咱们可以看到，程序能够很好的运行，我们现在要确定一个问题，if……else if能不能也像这样简化，下面我们来尝试着简化一下：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	int a;
	scanf("%d", &a);
	if (a == 1)
	else if (a == 2)
	else if (a == 3)
	else if (a == 4)
	else if (a == 5)
	{
		printf("工作日");
		return 0;
	}
	else if (a == 6)
	else if (a == 7)
	{
		printf("休息日");
		return 0;
	}
	return 0;
}

接下来我们来运行看看结果如何：

从这些报错中我们可以看到，if……else if后面是需要输入语句的，也就是说，即使在不同的情况下语句都相同，它还是需要在每一个if、else if后面加入语句，现在从这一点就证明了一件事，switch语句确实是在多分支语句的情况下能够更加简洁。

下面我有个问题，既然break在switch语句中能够使用，那我能不能在if语句中使用呢？接下来我们就来测试一下：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	int x, y, z;
	scanf("%d%d%d", &x, &y, &z);
	if (x > y && y > z)
	{
		printf("%d>%d>%d\nx>y>z\n", x, y, z);
		break;
	}
	else if (x > z && z > y)
	{
		printf("%d>%d>%d\nx>z>y\n", x, z, y);
		break;
	}
	else if (y > x && x > z)
	{
		printf("%d>%d>%d\nx>z>y\n", y, x, z);
		break;
	}
	else if (y > z && z > x)
	{
		printf("%d>%d>%d\nx>z>y\n", y, z, x);
		break;
	}
	else if (z > x && x > y)
	{
		printf("%d>%d>%d\nx>z>y\n", z, x, y);
		break;
	}
	printf("%d>%d>%d\nx>z>y\n", z, y, x);
	break;
	return 0;
}

这一次编写的代码，我们使用了上一篇if语句中提到的知识点，省略else的用法，下面我们来测试一下：

从报错中我们可以看到，这里描述的是break的使用范围，break只能在循环或者开关中使用。

有朋友可能就会问了，这个循环我能理解，是循环语句，这个开关是什么？

这里我同样也抱有这个疑问，然后我去查阅了资料，最后得到的结论是：

switch语句又叫做开关语句；

这里的开关就是指的switch语句。接下来我们来对这一部分内容做个小结：

1. 在switch语句中switch的判断条件是整型表达式，case的分支条件是整型常量表达式；
2. 在多分支语句中switch语句比if语句要更简洁；
3. 转向语句break就好比一堵墙，能把switch语句中的不同分支给独立出来，使它们互不干扰；
4. break语句除了可以在开关语句——switch语句中使用，还能在循环语句中使用；

注：我们在写代码的过程中一定要养成case后面加上break的习惯，如果出现了像咱们今天举的例子，多个case执行同一个语句时，我们只需要在最后一个case后面加上break就行。

3.default子句

有个问题不知道大家有没有考虑过，就是如果我们在switch语句中输入了case情况外的值，又会发生什么呢？

没错，它的结果就是什么都不发生，但是大家应该都有过忘记密码的体验，我们在输错密码时系统会提示我们密码错误，我们能不能按照这个逻辑在switch语句中表示出来呢？

答案是当然可以，这就是我们要探讨的default子句。

这个default子句就像是另一种形式的case语句，它可以放在任何一个switch语句的代码块中的任何位置，但是它又和case有些区别，case的分支条件是整型常量表达式，default语句是只要不满足case的一切条件。下面我们举例来验证：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	int a;
	scanf("%d", &a);
	switch (a)
	{
	case 1:
	case 2:
	case 3:
	case 4:
	case 5:
		printf("工作日");
		break;
	case 6:
	case 7:
		printf("休息日");
		break;
	default:
		printf("输入错误\n");
		break;
	}
	return 0;
}

下面我们输入8、a、“.”来测试一下结果：

输入8后，因为不是case的情况，所以此时输出的是输入错误；

输入a后，因为a同样也不是case的情况，所以也是输出输入错误；

输入.后，因为.同样也不是case的情况，所以也是输出输入错误；

上述结果证明了，只要我们输入的不是case的分支条件，那default就会被执行，下面我们来验证一下default是不是在switch代码块内可以放在任何位置。

此时我们将default放在case 1的前面，我们可以看到，此时是能够正常运行的；

现在我们将default放在case 3和case 4的中间，可以看到程序同样也是能正常运行的；

通过这次测试，我们也验证了default在switch语句的代码块内可以放在任何位置。

你们说既然default是包括了所有不满足case语句的情况，那我们可不可以写多个default来执行不同的内容呢？我们继续测试：

从这次的报错中我们就能得到结论，在switch语句中，只能出现一个default。下面我们把default相关内容做个总结：

1. default包含了所有的不满足case分支条件的情况；
2. default可以放在switch语句代码块中的任何位置；
3. 在switch语句中只能存在一个default。
4. switch语句我们可以写成下面这种结构：

//switch语句结构
switch (整型表达式)
{
	case 整型常量表达式：
		语句；
		break;
	default://后面的内容可写可不写，建议养成加上default的好习惯；
		语句;
		break;
}

现在我们已经把switch语句的内容探讨完了，后面如果有新的内容，我也会第一时间跟大家分享。接下来我们来做一道练习题巩固一下switch语句的相关知识：

//练习题：
int main()
{
	int n = 1;
	int m = 2;
	switch (n)
	{
	case 1:
		m++;
	case 2:
		n++;
	case 3:
		switch (n)
		{
		case 1:
			n++;
		case 2:
			m++;
			n++;
			break;
		}
	case 4:
		m++;
		break;
	default:
		break;
	}
	printf("m = %d,n = %d\n", m, n);
	return 0;
}

大家可以先笔试算出结果，再进行电脑来验证，在后面的内容中，我会分享这道题目的解析，记得关注哦。

到这里我们就已经把分支语句的内容探讨完了，接下来，我们将要开始进行循环语句内容的探讨啦！！！

（三）循环语句

在C语言中，循环结构的体现就是循环语句。在前面的学习中我们知道了，循环语句就是在满足条件的情况下重复去做一件事，直到不满足条件为止。循环语句分三类：while语句、for语句、do……while语句。今天我们要探讨的是第一种while语句。

while语句

1.while循环的语句结构

//while语句结构
while (表达式)
{
	执行语句;
	递进语句;
}

从结构中我们可以看到while语句其实跟if语句挺相似的：

相同点：两者都是先判断条件是否为真，判断为真，则执行条件下的指令，判断为假，则执行条件外的指令；

相异点：两者的区别是if语句下的指令只执行一次，而while语句下的指令可以重复多次的执行。

2.while循环的执行流程

从执行流程我们可以看到while语句除了正常判断条件外，还可能存在特殊情况，这里的特殊情况就是指的break和continue这两个关键字，下面我们就来探讨一下这两个关键字在循环语句中的作用。

3.while语句中的break和continue

break

在开关语句——switch语句中我们就有介绍到，作为转向语句，它在switch中的作用就是将不同的情况给独立出来，使它们各个情况之间互不干扰。break的含义是停止、打断的意思，它在循环语句中又会起到什么作用呢？接下来我们通过代码来探讨一下：

现在这行代码程序正常执行时能够将数字0~10全部打印出来，如下图所示：

现在我们在其中加入break试一下，这里我们需要嵌套一个if语句，代码如下：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	int a = 0;
	while (a <= 10)
	{
		if (a == 5)
		{
			break;
		}
		printf("%d\n", a);
		a++;
	}
	return 0;
}

在程序运行前，大家不妨猜测一下，此时的结果又会如何？那废话不多说，我们一起来看看运行结果：

这个结果跟大家推测的结果有出入吗？为什么会是这个结果呢？接下来我们来监视一下程序，前面的过程我相信大家都应该很清楚了，现在我们直接来看关键部分：

此时已经满足了if语句的判定，进入if执行语句break，下面我们继续执行：

这里我们可以看到，当程序走到break之后，下一步程序直接跳出来循环，也就是循环直接被终止了，下面我们在循环外加入一行代码，看看结果又会如何：

此时程序直接从break跳到了循环外的执行语句，从上面的测试结果我们可以得到结论：

break在循环语句中的作用就是终止循环，也就是说在循环语句中，只要遇到break，就停止后期的所有循环内容，直接跳出循环。

接下来我们继续探讨continue在循环中的作用。

continue

关键字continue——继续，从字面意思我们可以推测它是继续循环的意思，那问题就来了，我就算不要continue，只要不满足条件它也是能继续的呀，为什么还要额外引用一个continue呢？难道它的作用跟我们理解的继续有点出入？话不多说，咱们直接通过代码来探讨一下：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	int a = 0;
	while (a <= 10)
	{
		if (a == 5)
		{
			continue;
		}
		printf("%d\n", a);
		a++;
	}
	printf("感谢各位吴彦祖刘亦菲观看本文");
	return 0;
}

下面在运行前，咱们先推测一下它的结果会是什么？接下来咱们来验证一下自己的推测：

诶！结果跟我自己推测的有点出入，而且从控制台窗口显示，程序并未结束，还在继续执行，为什么会这样呢？我们来监视一下：

现在已经满足条件，进入if语句中，下面继续执行：

哇！不是吧，它并没有像我想象的那样继续执行循环内的语句，反而跳过后面的语句直接进入判定了，这样a的值永远不会发生变化，难怪刚才的结果是程序并未结束，那如果我把a++移动到if语句前，结果又会发生什么样的变化呢？

这里我们看到除了5以外，其它内容都打印了，那说明只有在a=5时，进入continue，然后直接跳过了后面的执行内容回到判断，由此我们可以的出结论：

continue是用于终止本次循环，也就是在本次循环中，continue后面的代码不会执行，或者说是跳过后面的执行语句，直接回到判定部分，进行下一次循环的入口判断。

接下来我们来看几个代码：

//代码1
int main()
{
	int ch = 0;
	while ((ch = getchar()) != EOF)//getchar()——接收字符，相当于scanf("%c", &);
		//EOF——end of file——文件结束标志，值为-1;
	{
		putchar(ch);//putchar()——输出字符，相当于printf("%c", );
	}
	return 0;
}

//代码2
int main()
{
	char ch = '\0';
	while ((ch = getchar()) != EOF)
	{
		if (ch < '0' || ch>'9')
		{
			continue;
		}
		putchar(ch);
	}
	return 0;
}

下面我们先认识一下这些代码及其含义：

getchar——接收字符，也就是我们自己输入字符，它会将输入的字符存起来，相当于scanf函数，如图所示；

程序运行后我们可以看到，窗口此时是需要我们输入内容的，和scanf函数一样，这时我们输入字符a；

putchar——输出字符，也就是在屏幕上将字符打印出来，相当于printf函数，如图所示；

在我们输入字符a后输出的结果为两个a，第二个a是printf打印出来的，第1个a只能是putchar打印出来的了。这里我们进一步证实了getchar和putchar的功能；

EOF——文件结束标志，是end of file的首字母大写，相当于\0，但是两者还是有些区别它本身的值为-1，如下图所示；

我们将EOF的值打印出来看一下：

可以看到\0的值为0，EOF的值为-1，\0是字符串的结束标志，EOF是文件的结束标志，两者作用的对象也不相同，一个作用于字符串，一个作用于文件。

在了解了这些对我们来说比较陌生的内容后，接下来我们来理解一下这几个代码；

//代码1
int main()
{
	int ch = 0;
	while ((ch = getchar()) != EOF)//getchar()——接收字符，相当于scanf("%c", &);
		//EOF——end of file——文件结束标志，值为-1;
	{
		putchar(ch);//putchar()——输出字符，相当于printf("%c", );
	}
	return 0;
}

在这个代码里面我们看到了while语句，也就是意味着只要我们输入的值不等于文件结束标志，我们就能一直输入，是不是这样呢？我们来试一下，依次输入A/BC/EOF/Ctrl+Z（文件结束标志）来看看结果：

最后一个^Z是输入的CTRL Z，我们可以看到输入前面的内容，它都能继续执行，但是输入CTRL Z后程序终止运行了。

可能这里有朋友就会问了，为什么你上面输入EOF没有用，这里我的理解是EOF它仅仅只是三个字符，这些字符被getchar一个一个识别后再一个一个打印出来，并没有任何附加功能，但是CTRL Z可以算是一个快捷键，这个快捷键的作用就是输入文件结束标志.

有细心的朋友会注意到我们前面的附图中，EOF显示的是#define EOF (-1)根据我们之前学到的知识可以知道，EOF其实是#define定义的标识符常量，下面是我通过联机搜索到的内容：

第一个代码我理解的意思就是可以连续输入除了文件结束标志以外的字符，输入完的字符，计算机会第一时间给输出出来。

下面我们来看第二个代码：

//代码2
int main()
{
	char ch = '\0';
	while ((ch = getchar()) != EOF)
	{
		if (ch < '0' || ch>'9')
		{
			continue;
		}
		putchar(ch);
	}
	return 0;
}

这个代码我们在理解前要回顾一下ASCII码值：

大家可以看一下我们的字符0和字符9所在的位置，然后我们再回过来看看if判断条件<'0' || >'9'这个区间范围是出来字符0~9的所有字符，然后他在这个范围内执行的语句是continue，跳过本次循环，回到while条件判断，这个意思是不是输入字符0~9外的其它字符都无法打印，只能打印0~9的字符，下面我们就来验证一下：

这里我们可以看到除了0~9的字符外，输入其它的字符都无法打印，所以我们可以下一个结论，这个代码是来打印数字字符的代码。

while循环咱们先探讨到这里，接下来咱们将继续探讨第二个循环语句——for语句。

for语句

1.for循环的语句结构

在开始for循环之前，我们先来探讨一个问题，为什么在C语言中已经有while循环了，还要加入for循环呢？我们来对比一下二者的语句结构：

//while语句结构
对象语句;//循环对象的初始化；
while (条件语句;)//对象是否进入循环的判断；
{
	执行语句;
	递进语句;//调整对象，使其避免死循环；
}

//for语句结构
for (对象语句; 条件语句; 递进语句)
{
	执行语句;
}

我们可以从两者的结构看到，while语句的与对象有关的三要素是分开的，这会有一个缺陷，如果这三者间存在很多很多的内容，那就会使它们离得很远，要是在编写的过程中，我想要修改其中一个内容，寻找起来会比较麻烦，而且还有可能出现像前面介绍continue时while陷入死循环的情况。

那有朋友可能就会说，我直接把它们放一起好了，这里是不是就像我们for语句结构一样了，直接将它们三者放在一个括号里，这样想修改时，只需要找到for语句这一行就能随时修改了，会比较方便。既然已经说到这里了，那我们就继续探讨一下for循环的语句流程吧：

2.for循环的执行流程

从流程图中我们可以看到，程序在进入for循环后执行顺序是1->2->3->4->2->3->4……后面2/3/4一直按照顺序去循环，直到判断为假，才会结束循环，大家还记得while的语句流程吗？

这里我们把它细化了一下，大家来对比一下两者异同点：

3.for循环与while循环的比较

相同点

• 都是先由对象语句到判断语句再开始选择进入循环内还是循环外的执行语句，最后由执行语句到递进语句后再回到判断语句；
• 在判断语句中都是进行真假判断，遵循0为假非0为真的逻辑进行判断，结果为0，执行循环外的语句，结果为非0，执行循环内的语句；
• 在执行语句中遇到break时，都是直接跳到循环外的执行语句；

不同点

• 进入循环的节点不同，for语句是在对象语句前就进入循环了，而while循环是在对象语句后再进入循环；
• 语句执行的逻辑不同，for循环的执行逻辑是判断->执行->递进按照此逻辑顺序不断重复，而while循环则会根据递进语句的位置而改变逻辑——
• （1）递进语句在执行语句前，则是判断->递进->执行；
• （2）递进语句在执行语句后，则是判断->执行->递进；
• 在执行语句中，for语句遇到continue时是跳到递进语句，再到判断语句，其逻辑顺序为判断->执行->continue->递进->判断，而while循环则是直接到判断语句，根据递进语句位置的不同其逻辑顺序也会有些许差异：
• （1）递进语句在执行语句前，则是判断->递进->执行->continue->判断；
• （2）递进语句在执行语句后，则是判断->执行->continue->判断；

由此我们可以看出，在语句的使用上for循环确实比while循环方便很多，因为for循环的逻辑顺序使它不会陷入死循环中，而while循环则会因为递进语句的位置不同导致其可能会陷入死循环。

4.for循环的循环控制变量

在for循环中变量的写法有两种：

//前闭后开的写法
for (int i = 0; i < 10; i++)
{
	执行语句;
}
//前闭后闭的写法
for (int i = 0; i <= 9; i++)
{
	执行语句;
}

这两种写法都对，可以依照个人的喜好自行选择，但是第一种相比于第二种来说，多了一些意义，在第一种前闭后开的写法中判断语句i<10，这里的10既是我们此时for语句的循环次数，也是执行语句的执行次数，更是变量i的个数，我们可以从这种写法中直接判断出for语句在正常运行时需要执行多少次。当然也不一定适用于所有情况，这个写法的问题各位朋友可以自行斟酌。

这里有一点需要注意，我们的变量尽量不要在循环体内去修改，防止变量失去for循环的控制，从而进入死循环。什么意思呢？下面我们通过代码来进一步理解：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	for (int a = 0; a < 10; a++)
	{
		if (a = 5)
		{
			printf("haha%d\n", a); 
			continue;
		}
		printf("haha%d\n", a);
	}
	return 0;
}

我们来执行一下，看看它会发生什么结果：

从运行结果中我们可以看到，此时循环并未结束，一直打印的是a=5的情况，为什么会这样呢？

这里我们来分析一下这个代码中的选择语句if(a= 5)，此时if中使用的操作符时“=”不是“==”，“=”的意思是赋值，此时的语句意思是将5赋值给a，在回到判断语句时一直重复的是6<10判断为真，进入循环，在这里我们通过这一句改变了变量的值，从而导致变量失去了for的控制，并不能很好的进行递进；而操作符“==”的意思是判断相等，这里只起一个判断作用，并未改变变量的值，我们看一下它的打印结果：

这里我们可以看到，正常打印，并未影响for语句对变量a的控制。从这个例子中我们能得出结论：

如果在循环体内改变了循环变量，可能会导致循环变量失去for的控制，建议尽量不要在循环体内改变循环变量。

5.一些for循环的变种

（1）变种1——省略变量、判断、递进：

在for循环中，我们是可以省略变量、判断和递进的，但是，for循环的判断部分如果被省略了，那判断条件就是恒为正。下面我们来分别探讨这几个问题：

正常编写for语句：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	int a = 0, b = 0, c = 0;
	for (a = 0; a < 5; a++)
	{
		c++;
		for (b = 0; b < 5; b++)
		{
			printf("hehe%d\n", c);
			c++;
		}
		printf("%d\n", c);
	}
	return 0;
}

这里我们看一下，它会打印多少个hehe：

总共是可以打印25个呵呵，接下来我们开始依次省略变量、判断、递进。

省略变量：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	int a = 0, b = 0, c = 0;
	for (; a < 5; a++)
	{
		c++;
		for (; b < 5; b++)
		{
			printf("hehe%d\n", c);
			c++;
		}
		printf("%d\n", c);
	}
	return 0;
}

大家可以猜一下我们会打印几个hehe？大家都想好了吗？下面我们就来揭晓答案：

总共打印了5个，和大家设想的结果是否一致呢？下面我们就来看一下在b=5之后循环内发生了什么：

此时b=5，跳出了第二个for循环；

这里我们可以看到在跳出第二个for循环后将c打印了出来，c此时为6；

这时程序进入了第一个for循环，这时a执行了a++然后再去判断是否小于5，这里涉及一个知识点后置++是先使用再++，所以此时我们看到的a仍然为0；

现在程序运行到了c++这一行，我们也能看到此时a=1，b=5,；

现在我们又进入了第二个循环，此时可以看到b仍为5，也就是说，第二个循环会被直接跳过。这里我们可以得出结论：

省略for循环中的变量语句后，变量在进入循环时并不能初始化；

省略判断：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	int a = 0, b = 0, c = 0;
	for (a = 0;; a++)
	{
		c++;
		for (b = 0;; b++)
		{
			printf("hehe%d\n", c);
			c++;
		}
		printf("%d\n", c);
	}
	return 0;
}

下面我们来看看程序会如何执行：

此时程序已经走完了6次循环此时a=0，b=5，c=7，打印结果为hehe6；

这时程序继续走完了一个循环，我们只能看到打印继续执行hehe，b和c的值也在继续增加，并未有结束循环的条件，也就是说此时语句在第二个循环中进入了死循环，这里我们可以得出结论：

省略for循环中的判断后，循环的判断结果恒为正，循环将进入死循环；

省略递进：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	int a = 0, b = 0, c = 0;
	for (a = 0; a < 5;)
	{
		c++;
		for (b = 0; b < 5;)
		{
			printf("hehe%d\n", c);
			c++;
		}
		printf("%d\n", c);
	}
	return 0;
}

我们来监视一下结果：

第一次循环走完，此时a=0，b=0，c=2，打印了hehe1；

第二次循环走完，此时a=0，b=0，c=3，打印了hehe2。也就是说在省略递进后，变量因为不会被改变，从而导致判断条件始终满足而导致循环进入死循环，这里我们可以得出结论：

省略for循环中的递进语句后，循环会因变量无法改变，导致判断结果始终不变，从而使循环进入死循环。

（2）变种2——使用多个变量控制循环：

在for循环中我们也可以通过多个变量来控制循环，下面我们通过代码来理解：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>

int main()
{
	int c = 0;
	for (int x = 0,  y = 0; x < 3 && y < 5; x++, ++)
	{
		c++;
		printf("hehe%d\n", c);
	}
	return 0;
}

从这个代码中我们就可以看到，此时的for循环中通过变量x和变量y来进行控制，能否正常运行呢？我们来运行一下：

我们可以看到循环能够正常运行，这里我们可以得到结论：

在for循环中，for循环是可以通过多个变量来控制的。

这里大家只要简单了解一下就可以了，如果随着后续的学习，这一块知识点会继续深入的话，我也会第一时间来跟大家分享的。

最后咱们留下一道题给各位，来帮助各位进一步去理解for循环的知识点：

//for循环题目
int main()
{
	int i = 0, k = 0;
	for (i = 0, k = 0; k = 0; i++, k++)
	{
		k++;
	}
	return 0;
}//请问循环要循环几次？

 for循环的内容到这里也全部介绍完了，下面我们来看看最后一个循环语句do……while语句；

do……while语句

1.do……while循环的语句结构

//do……while语句结构
对象语句;
do
{
	执行语句;
	递进语句;
} while (条件语句);

接下来我们看看do……while语句的执行流程；

2.do……while循环的执行流程

从这个流程图中我们可以看到，do……while语句跟while语句和if语句有一个最明显的不同，就是它的条件语句在后面，这样的流程有什么特点呢？

3.do……while循环的语句特点

从流程图中我们可以知道当程序开始运行时，相比于其它两个循环语句，do……while语句肯定会执行一次，这样就给此语句带来了局限性，所以不是经常使用。

4.与while语句的异同点

接下来我们通过流程图来看看do……while语句和while语句有哪些异同点：

相同点：

1. 两者都是从对象语句之后进入循环；
2. 两者的判断都是由while进行判断；
3. 判断语句都是遵循0为假跳出循环，非0为真进入循环；
4. 在执行语句中遇到break时，直接跳出循环执行循环外的执行语句；
5. 在执行语句中遇到continue时，都有两种情况:（1）递进语句在执行语句后；（2）递进语句在执行语句前；

不同点：

1.语句逻辑不同：

（1）递进语句在执行语句后：

while语句：判断->执行->递进；

do……while语句：执行->递进->判断；

（2）递进语句在执行语句前：

while语句：判断->递进->执行；

do……while语句：递进->执行->判断；

2.执行语句遇到continue时，语句执行逻辑不同：

递进语句在执行语句后:

while语句：判断->执行->continue->判断；

do……while语句：执行->continue->判断->执行；

递进语句在执行语句前:

while语句：判断->递进->执行->continue->判断；

do……while语句：递进->执行->continue->判断->递进；

到这里do……while语句的内容也全部介绍完了，内容不多，也不复杂。

现在循环语句的全部内容同样也都介绍完了，希望各位能够掌握这三种循环语句的异同点，这样在今后编码的过程中会更加的得心应手。

接下来我们来介绍一下转向语句的相关内容；

（四）转向语句

goto语句

1.理解：

goto语句是作为转向语句的一种。goto语句也被称为无条件转移语句，我对它的理解是去往、前往的意思，具体是去哪里，那就需要根据实际情况来决定了。

2.使用方法：

goto语句的使用格式是：

//语句结构
标识符://标识符后跟一个冒号；
正常语句;
goto 标识符;//goto语句后跟上标识符，中间用空格隔开，标识符后跟分号代表语句结束；

它具体是如何使用的，这里我们来举个例子，以打印1-9为例：

int main()
{
	int a = 0;
	b:
	for (a = 0; a < 10; a++)
	{
		printf("%d ", a);
		if (5 == a)
		{
			goto b;
		}
	}
	return 0;
}

这个代码我们已经接触过很多次了，今天就不在重复看正常运行的结果了，但是本次编码过程中我在for语句前加了一个标识符b，在循环内加了一个if条件语句，条件语句的执行语句为goto b;这种情况下程序又会如何执行呢？下面我们来运行一下：

这里我们可以看到，程序进入了死循环，为什么会这样呢，我们来看看这个代码的运行流程：

从执行流程中我们可以看到，通过goto语句，每次在运行到a=5时就会跳转到循环外，从a=0开始进入循环判断，判定结果肯定为真，然后进入循环，这样就导致了程序无法走出for循环，这就是为什么运行结果是一个死循环。从这个例子我们可以得到下列结论：

1. goto语句后面跟的标识符不需要额外定义可以根据自己的喜好来编写，只需要在标识符后面加一个冒号就可以了；
2. goto语句在进行跳转时并没有任何条件限制，所以是无条件跳转，在使用时只需要goto加上前面有加冒号的标识符；

3.适用场合：

从上述例子我们可以看到，如果我们在代码中随意乱用标识符的话就很容易产生bug，那我们应该如何使用呢？请看下面的例子：

int main()
{
	int a, b, c, d;
	for (a = 0; a < 10; a++)
	{
		for (b = 0; b < a; b++)
		{
			for (c = 0; c < b; c++)
			{
				d = a + b + c;
				if (b + c > a)
				{
					goto sum;
				}
			}
		}
	}
sum:
	printf("%d+%d+%d=%d\n", a,b,c,d);
	return 0;
}

这里我们嵌套了多个循环，如果我们我们正常运行的话它会从最里面的循环一层一层的结束循环然后跳出循环，但是我们在最里层的循环加一个goto语句的话会有什么结果呢？

我们从这个结果可以看到，相比于一层一层的结束循环，使用goto语句能更快的跳出循环，大大提高了运行效率，这里我们可以做个总结：

1.goto语句作为无条件转移语句，如果随意使用，容易出现bug，在循环中容易进入死循环；

2.goto语句在深层嵌套中用来跳出嵌套的话，可以大大提高程序的运行效率。

下面咱们来进行实操加深对goto语句的理解：

4.实操理解：

接下来我们来编写一个关机的小程序，在编写代码前，我们先来了解几个知识点：

1.电脑关机命令shutdown -s -t 60:-s——设置关闭，-t——设置时间， 60——60s；

2.cmd——command——命令行，可以通过电脑开始菜单里输入cmd；

3.取消关机命令：shutdown -a：-a——中止系统关闭，仅限在时限内使用；

4.system——执行系统命令函数；

在了解了这些内容之后，我们开始编写代码吧：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
	char a[20] = { 0 };//定义字符数组接受输入的字符；
	again://标识符again为goto语句的跳转标志；
	system("shutdown -s -t 60");//通过system函数执行系统命令，需要调用头文件<stdlib.h>；
	printf("您的电脑将在1分钟后关闭，请输入one piece取消关机>;");
	scanf("%s", a);
	if (strcmp(a, "one piece") == 0)//strcmp——string compare字符串比较函数，需要调用头文件<string.h>；
	{
		system("shutdown -a");
	}
	else
	{
		goto again;
	}
	return 0;
}

这里咱们的代码就编码完成了，有兴趣的朋友可以去试一下。

慎用！！！整蛊小妙招：

在咱们存放项目的文件夹里找到debug文件夹点进去，会看到一个后缀名为.exe的文件：

这个就是咱们编写的程序，我们可以通过Ctrl+Alt+.打开任务管理器，之后选择文件->建立新任务->输入cmd->勾选以系统管理权限创建此任务->点击确定进入cmd窗口

在窗口内输入下面的代码：

sc create servicename binpath="你想要添加的程序的存放路径"

回车之后程序就成功添加进你的电脑服务中了：

我们只需要将单击此电脑，右键选择管理，找到服务与应用程序，点击服务，再寻找刚刚添加进去的新文件，将它的启动类型改为自动，这样你添加的程序就能自动运行了，具体要怎么使用，那就因人而异了。

结语

C语言总集篇——分支与循环的全部内容到这里咱们就全部介绍完了，希望这篇内容能帮助大家更好的学习和复习分支与循环的相关内容。

各位如果喜欢博主的内容，还请来一套点赞、关注、转发三连招。

今天的内容到这里就全部结束了，接下来我会继续给大家分享C语言学习的相关知识点，咱们下一篇再见。