分支和循环语句

1、什么是语句

C语句可分为以下五类：

1、表达式语句

2、函数调用语句

3、控制语句

4、复合语句

5、空语句

本章后面介绍的是控制语句。

        控制语句用于控制程序的执行流程，以实现程序的各种结构方式（C语言支持三种结构：顺序结构、选择结构、循环结构），它们由特定的语句定义符组成，C语言有九种控制语句。

可分成以下三类：

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

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

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

2、分支语句（选择结构）

2.1 if 语句

if 语句的语法结构：

if(表达式)
    语句;

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

//多分支    
if(表达式1)
    语句1;
else if(表达式2)
    语句2;
else
    语句3;

示例代码：

// 代码1
#include <stdio.h>
int main()
{
	int age = 0;
	scanf("%d", &age);
	if (age < 18)
	{
		printf("未成年\n");
	}
}

// 代码2
#include <stdio.h>
int main()
{
	int age = 0;
	scanf("%d", &age);
	if (age < 18)
	{
		printf("未成年\n");
	}
	else
	{
		printf("成年\n");
	}
}

// 代码3
#include <stdio.h>
int main()
{
	// <18       青少年
	// [18, 30)  青年
	// [30, 50)  中年
	// [50, 80)  中老年
	// [80, 100) 老寿星
	int age = 0;
	scanf("%d", &age);
	if (age < 18)
		printf("少年\n");
	else if (age >= 18 && age < 30)
		printf("青年\n");
	else if (age >= 30 && age < 50)
		printf("中年\n");
	else if (age >= 50 && age < 80)
		printf("老年\n");
	else
		printf("老寿星\n");
}

解释一下：

如果表达式的结果为真，则语句执行。

在C语言中，0表示假，非0表示真。

如果条件成立，要执行多条语句，应该使用代码块。

#include <stdio.h>
int main()
{
    if(表达式)
    {
        语句列表1;
    }
    else
    {
        语句列表2;
    }
    return 0;
}

这里的一对{ }就是一个代码块。

2.1.1 悬空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;
}

实际上，上述代码 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;
}

else 的匹配：else 是和它离的最近的 if 匹配的。

2.1.2 if 书写形式的对比

将代码1和代码2对比，代码3和代码4对比：

代码1：

// 代码1
if (condition)
{
	return x;
}
return y;

代码2：

// 代码2
if (condition)
{
	return x;
}
else
{
	return y;
}

代码2更好。代码1和代码2逻辑是一样的，但是代码2更容易理解。

代码3：

// 代码3
int num = 1;
if (num == 5)
{
	printf("hehe\n");
}

代码4：

// 代码3
int num = 1;
if (5 == num)
{
	printf("hehe\n");
}

代码3的 num == 5，在写代码时，可能会写出num = 5，这样编译器是不会报错的；如果写成

5 == num，若少写了一个等号，编译器能发现错误。

代码2和代码4更好，逻辑更加清晰，不容易出错。

2.1.3 练习

1、判断一个数是否为奇数。

#include <stdio.h>

int main()
{
	int num = 0;
	scanf("%d", &num);
	if (0 == num % 2)
		printf("%d 不是奇数\n", num);
	else
		printf("%d 是奇数\n", num);
	return 0;
}

2、输出1-100之间的奇数。

#include <stdio.h>

int main()
{
	int i = 1;
	while (i <= 100)
	{
		//判断i是奇数的话，就打印i
		if(i % 2 == 1)
			printf("%d ", i);
		++i;
	}
	return 0;
}

2.2 switch 语句

switch 语句也是一种分支语句。

常常用于多分支的情况。

比如：

输入1，输出星期一

输入2，输出星期二

输入3，输出星期三

输入4，输出星期四

输入5，输出星期五

输入6，输出星期六

输入7，输出星期日

写成 if ... else if ... else if 的形式太复杂，那我们就得有不一样的语法形式。

#include <stdio.h>
int main()
{
	int day = 0;
	//输入
	scanf("%d", &day);
	if (1 == day)
		printf("星期1\n");
	else if (2 == day)
		printf("星期2\n");
	else if (3 == day)
		printf("星期3\n");
	else if (4 == day)
		printf("星期4\n");
	else if (5 == day)
		printf("星期5\n");
	else if (6 == day)
		printf("星期6\n");
	else if (7 == day)
		printf("星期天\n");
	else
		printf("输入错误\n");

	return 0;
}

这就是 switch 语句。

switch(整型表达式)// 注意这是要求整型表达式
{
    语句项;
}

而语句项是什么呢？

// 是一些 case 语句
// 如下：
case 整型常量表达式: // 注意这是要求整型常量表达式，const修饰的常变量也不行
    语句;

2.2.1 在 switch 语句中的 break

在switch语句中，我们没办法直接实现分支，搭配 break 使用才能实现真正的分支。

比如：

#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;
	}
	return 0;
}

输入3之后，程序到达case 3，打印星期三之后，break跳出switch语句。

有时候我们的需求变了：

1、输入1-5，输出的是“weekday”;

2、输入6-7，输出“weekend”

所以我们的代码就应该这样实现了：

#include <stdio.h>
//switch代码演示
int main()
{
	int day = 0;
	switch (day)
	{
	case 1:
	case 2:
	case 3:
	case 4:
	case 5:
		printf("weekday\n");
		break;
	case 6:
	case 7:
		printf("weekend\n");
		break;
	}
	return 0;
}

break 语句的实际效果是把语句列表划分为不同的分支部分。

编程好习惯：

在最后一个 case 语句的后面加上一条 break语句。 （之所以这么写是可以避免出现在以前的最后一个 case 语句后面忘了添加 break语句）。

2.2.2 default 子句

如果表达的值与所有的 case 标签的值都不匹配怎么办？

其实也没什么，结构就是所有的语句都被跳过而已。

程序并不会终止，也不会报错，因为这种情况在 C 中并不认为是个错误。

但是，如果你并不想忽略不匹配所有标签的表达式的值时该怎么办呢？

你可以在语句列表中增加一条 default 子句，把下面的标签

default:

写在任何一个 case 标签可以出现的位置。

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

但是它可以出现在语句列表的任何位置，而且语句流会像执行一个 case 标签一样执行 default 子句。

编程好习惯：

在每个 switch 语句中都放一条 default 子句是个好习惯，甚至可以在后边再加一个 break 。

2.2.3 练习

看看以下代码，输出什么？

#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;// break 只会跳出一层 switch
		}
	case 4:
		m++;
		break;
	default:
		break;
	}
	printf("m = %d, n = %d\n", m, n);
	return 0;
}
// 答案：打印 m = 5, n = 3

• switch 允许嵌套使用
• break 只会跳出一层 switch

3、循环语句

• while
• for
• do while

3.1 while 循环

我们已经掌握了，if 语句：

if(条件)
    语句;

当条件满足的情况下，if 语句后的语句执行，否则不执行。

但是这个语句只会执行一次。

由于我们发现生活中很多的实际的例子是：同一件事情我们需要完成很多次。

那我们怎么做呢？

C语言中给我们引入了：while 语句，可以实现循环。

// while 语法结构
while(表达式)
    循环语句;

while 语句执行的流程：

比如我们实现：在屏幕上打印1-10的数字。

#include <stdio.h>
int main()
{
	int i = 1;
	while (i <= 10)
	{
		printf("%d ", i);
		i = i + 1;
	}
	return 0;
}

上面的代码已经帮我了解了 while 语句的基本语法，那我们再了解一下：

3.1.1 while 语句中的 break 和 continue

break 介绍

// break 代码实例
#include <stdio.h>
int main()
{
	int i = 1;
	while (i <= 10)
	{
		if (i == 5)
			break;// break - （跳出）终止循环
		printf("%d ", i);
		i = i + 1;
	}
	return 0;
}

这段代码的输出结果是什么？

A、1 2 3 4

B、1 2 3 4 5

C、1 2 3 4 5 6 7 8 9 10

D、1 2 3 4 6 7 8 9 10

总结：

break在while循环中的作用：

• 其实在循环中只要遇到break，就停止后期的所有的循环，直接终止循环。
• 所以，while中的break是用于永久终止循环的。

continue 介绍

// continue 代码实例1
#include <stdio.h>
int main()
{
	int i = 1;
	while (i <= 10)
	{
		if (i == 5)
			continue;
		printf("%d ", i);
		i = i + 1;
	}
	return 0;
}

这段代码的输出结果是什么？

A、1 2 3 4

B、1 2 3 4 5

C、1 2 3 4 5 6 7 8 9 10

D、1 2 3 4 6 7 8 9 10

打印1 2 3 4后，光标一直闪烁，因为陷入了死循环。

// continue 代码实例2
#include <stdio.h>
int main()
{
	int i = 1;
	while (i <= 10)
	{
		i = i + 1;
		if (i == 5)
			continue;// 跳过本次循环continue后边的代码，直接去while循环的判断部分
		printf("%d ", i);
	}
	return 0;
}

这段代码的输出结果是什么？

A、1 2 3 4

B、1 2 3 4 5

C、1 2 3 4 5 6 7 8 9 10

D、1 2 3 4 6 7 8 9 10

E、 2 3 4 6 7 8 9 10 11

总结:

continue 在 while 循环中的作用就是：

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

3.1.2 再看几个代码

以下代码是什么意思？

代码1

// 代码1
#include <stdio.h>
int main()
{
	int ch = 0;
	while ((ch = getchar()) != EOF)
		putchar(ch);
	return 0;
}

// 这里的代码适当的修改是可以用来清理缓冲区的

getchar()：获取字符。

getchar 读取成功返回字符的 ASCII 码值，读取失败返回 EOF 。

上面代码执行结果：（ctrl + Z -> EOF）

看以下应用场景：

#include <stdio.h>
int main()
{
	char password[20] = {0};
	printf("请输入密码:>");
	scanf("%s", password);// 123456或者123456 abc
	printf("请确认密码(Y/N):");
	char input = 0;
    scanf("%c", &input);
    if ('Y' == input)
		printf("确认成功\n");
	else
		printf("确认失败\n");

	return 0;
}

这里我还没有输入Y/N，就显示确认失败了。这是为什么呢？

scanf 和 getchar 并不是直接从键盘上拿数据，而是从输入缓冲区拿的。键盘输入数据放在缓冲区里。

scanf 拿走的缓冲区里的 123456，然后缓冲区剩下 \n 。然后打印“请确认密码(Y/N):”，scanf 又来看缓冲区，发现缓冲区里有 \n，scanf需要读取一个字符，因此把 \n 拿走了。

然后没有等待我们输入，就进行判断了，然后打印“确认失败”。

那怎么解决呢？

再 scanf 来之前，将 \n 处理掉

#include <stdio.h>
int main()
{
	char password[20] = { 0 };
	printf("请输入密码:>");
	scanf("%s", password);// 123456
	printf("请确认密码(Y/N):");
	char input = 0;
	//scanf("%c", &input);
	//把 \n 处理掉
	getchar();
	input = getchar();
	if ('Y' == input)
		printf("确认成功\n");
	else
		printf("确认失败\n");

	return 0;
}

但是，如果这样处理，还有问题。如果输入密码是“123456 abc”呢？

还是直接就确认失败了。

scanf 第一次来缓冲区看，拿走了“123456”。但是后面还有一串东西。但是getchar()只能清理一个字符，所以还是不会等待我们输入Y/N。

#include <stdio.h>
int main()
{
	char password[20] = { 0 };
	printf("请输入密码:>");
	scanf("%s", password);// 123456或者123456 abc
	printf("请确认密码(Y/N):");
	char input = 0;
	//scanf("%c", &input);
	//把 \n 处理掉
	//getchar();

	//清理掉缓冲区中剩余的数据
	while (getchar() != '\n')
	{
		;
	}
    //清空缓冲区还有一种写法
	//fflush(stdin);//达不到效果，因为在新版本的VS上这个函数的功能被取消了

	input = getchar();
	if ('Y' == input)
		printf("确认成功\n");
	else
		printf("确认失败\n");

	return 0;
}

代码2

// 代码2
#include <stdio.h>
int main()
{
	char ch = '\0';
	while ((ch = getchar()) != EOF)
	{
		if (ch < '0' || ch > '9')
			continue;
		putchar(ch);
	}
	return 0;
}
// 这个代码的作用是：只打印数字字符，跳过其他字符

这个代码的作用是：只打印数字字符，跳过其他字符。

3.2 for 循环

我们已经知道了while循环，但是我们为什么还要一个for循环呢？

首先来看看for循环的语法：

3.2.1 语法

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

表达式1

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

表达式2

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

表达式3

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

实际的问题：

使用 while 循环在屏幕上打印1-10的数字。

#include <stdio.h>
int main()
{
	int i = 1;
	while(i <= 10)
	{
		printf("%d ", i);
		i++;
	}
	return 0;
}

使用 for 循环在屏幕上打印1-10的数字。

#include <stdio.h>
int main()
{
	int i = 0;
	for (i = 1; i <= 10; i++)
	{
		printf("%d ", i);
	}
	return 0;
}

for 循环的执行流程图：

        可以发现在 while 循环中依然存在循环的三个必须条件，但是由于风格的问题使得三个部分很可能偏离较远，这样查找修改就不够集中和方便。所以，for 循环的风格更胜一筹；for 循环使用的频率也最高。

3.2.2 for 循环中的 break 和 continue

我们发现在 for 循环中也可以出现 break 和 continue，他们的意义和在 while 循环中是一样的。 但是还是有些差异：

代码1：

//代码1
#include <stdio.h>
int main()
{
	int i = 0;
	for (i = 1; i <= 10; i++)
	{
		if (i == 5)
			break;
		printf("%d ", i);
	}
	return 0;
}

代码2：

//代码2
#include <stdio.h>
int main()
{
	int i = 0;
	for (i = 1; i <= 10; i++)
	{
		if (i == 5)
			continue;
		printf("%d ", i);
	}
	return 0;
}

3.2.3 for 循环的循环控制变量

建议：

1、不可在 for 循环体内修改循环变量，防止 for 循环失去控制。

2、建议 for 语句的循环控制变量的取值采用“前闭后开区间”写法。

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

//两边都是闭区间
for (i = 0; i <= 9; i++)
{
}

3.2.4 一些 for 循环的变种

代码1

// 代码1
#include <stdio.h>
int main()
{
	for (;;)
	{
		printf("hehe\n");
	}
	// for循环中的初始化部分，判断部分，调整部分是可以省略的，但是不建议初学时省略，容易导致问题。
	return 0;
}

上面代码运行结果：一直打印 hehe 。

不建议省略，看一看代码2和代码3：

代码2

// 代码2
#include <stdio.h>
int main()
{
	int i = 0;
	int j = 0;
	// 这里打印多少个hehe?
	for (i = 0; i < 4; i++)
	{
		for (j = 0; j < 4; j++)
		{
			printf("hehe\n");
		}
	}
	return 0;
}

上述代码可以看出打印16次hehe。

i = 0，j 从0~3，打印4次；j++之后，j = 4，j < 4 判断为假，再 i++；

i = 1，j 从0~3，打印4次；j++之后，j = 4，j < 4 判断为假，再 i++；

i = 2，j 从0~3，打印4次；j++之后，j = 4，j < 4 判断为假，再 i++；

i = 3，j 从0~3，打印4次；j++之后，j = 4，j < 4 判断为假，再 i++；i = 4，i < 4 判断为假，整个循环结束。

总共16次。

代码3

// 代码3
#include <stdio.h>
int main()
{
	int i = 0;
	int j = 0;
	// 如果省略掉初始化部分，这里打印多少个hehe?
	for (; i < 4; i++)
	{
		for (; j < 4; j++)
		{
			printf("hehe\n");
		}
	}
	return 0;
}

为什么这个代码的结果只打印4次呢？

i = 0，j 从0~3，打印4次；j++之后，j = 4，j < 4 判断为假，再 i++；

i = 1，此时 j 并没有初始化，因此 j = 4，j < 4 判断为假，再 i++；

i = 2， j = 4，j < 4 判断为假，再 i++；

i = 3， j = 4，j < 4 判断为假，再 i++；i = 4，i < 4 判断为假，整个循环结束。

因此，只打印4次。

所以，一定要根据实际情况写代码。

代码4

// 代码4 - 使用多余一个变量控制循环
#include <stdio.h>
int main()
{
	int x, y;
	for (x = 0, y = 0; x < 2 && y < 5; ++x, y++)
	{
		printf("hehe\n");
	}
	return 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;
}
// 答案：0次

3.3 do...while()循环

3.3.1 语法

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

3.3.2 执行流程

3.3.3 do 语句的特点

循环至少执行一次，使用的场景有限，所以不是经常使用。

#include <stdio.h>
int main()
{
	int i = 1;
	do
	{
		printf("%d ", i);
		i = i + 1;
	} while (i <= 10);
	return 0;
}

3.3.4 do while 循环中的 break 和 continue

#include <stdio.h>
int main()
{
	int i = 1;
	do
	{
		if (5 == i)
			break;
		printf("%d ", i);
		i = i + 1;
	} while (i <= 10);
	return 0;
}

#include <stdio.h>
int main()
{
	int i = 1;
	do
	{
		if (5 == i)
			continue;
		printf("%d ", i);
		i = i + 1;
	} while (i <= 10);
	return 0;
}

打印1 2 3 4之后，光标一直在闪，因为陷入了死循环。

3.4 对于循环的练习

3.4.1 5道题

1、计算 n 的阶乘。

// 计算 n的阶乘
// 5! = 1*2*3*4*5
// n! = 1~n 累积想乘

// 不考虑溢出 
int main()
{
	int n = 0;
	scanf("%d", &n);
	int i = 0;
	int ret = 1;
	for (i = 1; i <= n; i++)
	{
		ret = ret * i;
	}
	printf("%d\n", ret);

	return 0;
}

2、计算1！+2！+3！+......+10！

// 计算 1!+ 2!+ 3!+ …… + 10!
#include <stdio.h>
int main()
{
	int i = 0, j = 0;
	int sum = 0, tmp = 1;
	for (i = 1; i <= 10; i++)
	{
		tmp = 1;
		for (j = 1; j <= i; j++)
		{
			tmp = tmp * j;
		}
		sum += tmp;
	}
	printf("%d\n", sum);

	return 0;
}

1!

2! = 1*2

3! = 1*2*3

4! = 1*2*3*4

5! = 1*2*3*4*5

发现有很多重复计算，可以将代码更改如下：

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

	return 0;
}

3、在一个有序数组中查找具体的某个数字 n。（二分查找）

方法1：一个一个找

#include <stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };//升序
	int key = 6;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		if (arr[i] == key)
		{
			printf("找到了，下标是:%d\n", i);
			break;
		}
	}
	if (i == 10)
	{
		printf("找不到了\n");
	}
	return 0;
}

但是没有利用有序的特点，因为无序的数组也可以这样找。

方法2：二分查找（重要）

1、确定被范围的左右下标 left、right；

2、根据 left 和right，确定中间元素的下标 mid；

3、根据 mid 锁定的元素，和查找的元素比较，确定新的查找范围，left 和 right。

#include <stdio.h>
int main()
{
	int arr[] = { -3, 1, 3, 5, 7, 11, 23, 44, 90, 91 };
	int left = 0;
	int right = sizeof(arr) / sizeof(arr[0]) - 1;// sizeof(arr)是整个数组的大小，sizeof(arr[0])是首元素的大小，sizeof(arr) / sizeof(arr[0])表示数组元素个数
	int key = 90;
	int mid = 0;
	while (left <= right)
	{
		mid = (left + right) / 2;
		if (arr[mid] > key)
		{
			right = mid - 1;
		}
		else if (arr[mid] < key)
		{
			left = mid + 1;
		}
		else
			break;
	}
	if (left <= right)
		printf("找到了,下标是%d\n", mid);
	else
		printf("找不到\n");
}

添加 flag 标志：

#include <stdio.h>
int main()
{
	int arr[] = { -3, 1, 3, 5, 7, 11, 23, 44, 90, 91 };
	int left = 0;
	int right = sizeof(arr) / sizeof(arr[0]) - 1;
	int key = 90;
	int mid = 0;
	int flag = 0;// flag的作用是标志是否找到了：1表示找到了，0表示没找到
	while (left <= right)
	{
		int mid = (left + right) / 2;
		if (arr[mid] == key)
		{
			printf("找到了,下标是:%d\n", mid);
			flag = 1;
			break;
		}
		else if (arr[mid] < key)
		{
			left = mid + 1;
		}
		else
		{
			right = mid - 1;
		}
	}
	if (flag == 0)
		printf("没找到\n");
	return 0;
}

4、编写代码，演示多个字符从两端移动，向中间汇聚。

例子：welcome to China!

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

int main()
{
	char arr1[20] = "welcome to China!";
	char arr2[20] = "#################";
	int left = 0, right = strlen(arr1) - 1;

	while (left <= right)
	{
		arr2[left] = arr1[left];
		arr2[right] = arr1[right];
		printf("%s\n", arr2);
		Sleep(1000);// Sleep()函数，设置1000ms，那么每打印一行就会等待1s
		left++;
		right--;
	}
	return 0;
}

想要只有一行显示的话：

#include <stdio.h>
#include <string.h>
#include <windows.h>
//Sleep()需要一个windows.h的头文件

int main()
{
	char arr1[20] = "welcome to China!";
	char arr2[20] = "#################";
	int left = 0, right = strlen(arr1) - 1;

	while (left <= right)
	{
		arr2[left] = arr1[left];
		arr2[right] = arr1[right];
		printf("%s\n", arr2);
		Sleep(1000);// Sleep()函数，设置1000ms，那么每打印一行就会等待1s
        system("cls");// system函数可以执行系统命令，cls是清理屏幕
		left++;
		right--;
	}
    printf("%s\n", arr2);
	return 0;
}

5、编写代码实现，模拟用户登录情景，并且只能登录三次。（只允许输入三次密码，如果密码正确则提示登录成，如果三次均输入错误，则退出程序）

// 假设密码是123456abc
#include <stdio.h>
#include <string.h>

int main()
{
	char password[20] = { 0 };
	int i = 0;
	int flag = 0;// flag = 1就表示登录成功，flag = 0就表示登录失败
	for (i = 0; i < 3; i++)
	{
		printf("请输入密码：");
		scanf("%s", password);// password是数组名，本身就是地址，所以这里没有用取地址&
		// 判断密码是否正确
		// 两个字符串比较相等是不能使用==的，应该使用strcmp库函数
		// if (password == "123456abc")
		// strcmp返回0表示2个字符串相等
		// strcmp返回>0的数字，表示第一个字符串大于第二个字符串
		// strcmp返回<0的数字，表示第一个字符串小于第二个字符串
		if (strcmp(password, "123456abc") == 0)
		{
			printf("登录成功！\n");
			flag = 1;
			break;
		}
		else
		{ 
			printf("密码错误\n");
		}
	}
	if (flag == 0)
	{
		printf("三次密码均输入错误，退出程序！\n");
	}
	return 0;
}

3.4.2 猜数字游戏

猜数字游戏：

1、电脑会随机生成一个数

2、猜数字

• 猜大了，提醒猜大了，继续猜；
• 猜小了，提醒猜小了，继续猜；
• 猜对了，显示”恭喜你，猜对了！“，结束游戏。

3、玩完一把不过瘾，可以选择继续玩，不用退出程序

打印菜单和游戏整体逻辑

#include <stdio.h>

// 打印菜单
void menu()
{
	printf("***********************\n");
	printf("****1.play   0.exit****\n");
	printf("***********************\n");
}

int main()
{
	int input = 0;
	do
	{
		// 打印菜单
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("猜数字游戏\n");
			break;
		case 0:
			printf("退出游戏！\n");
			break;
		default:
			printf("输入错误！\n");
			break;
		}
	} while (input);

	return 0;
}

游戏模块

将游戏部分封装成函数：

那么游戏分为两部分：

1、生成随机数

2、猜数字

生成随机数

介绍一下rand()函数：可以生成随机数，随机数的范围是：0~32767

我们这里先打印一下随机生成的数：会发现两次运行程序，生成的随机数竟然是一样的！！！

这个问题是，我们使用这个函数用错了！

上面的文档已经说了，使用rand()之前，需要使用srand()函数。

srand函数的作用是设置随机数发生器的种子值，用于初始化随机数生成器：

srand 函数接受一个整数参数作为种子值，可以用当前时间或者其他变化的值作为种子，这样设置后，可以确保每次程序运行时生成的随机数序列都是不同的。这样可以提高程序的随机性和可复现性。

srand需要传入unsigned int值：

我们发现，传入一个数字，生成一个数字；我们传入srand()的数字在变时，生成的数也在变。

因此，我们需要传入一个变化的数字即可，时间是时刻发生变化的。

时间在变化，那么时间戳也在一直变化。

时间戳怎么产生呢？C语言有一个time()函数，可以返回时间戳。

这里参数可以传入一个空指针，返回值为time_t，而srand()需要unsigned int类型。

因此，time_t其实就是long long类型，我们可以将time()函数的返回值强制转换成unsigned int类型。

但是，还有一个问题：虽然可以生成随机数，但是当快速选择1时，生成的随机数是一样的。

其实，srand()函数只用调用一次就可以了，不用每玩一次，就调用一次srand()设置随机数生成器的起点。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// 打印菜单
void menu()
{
	printf("***********************\n");
	printf("****1.play   0.exit****\n");
	printf("***********************\n");
}

void game()
{
	// 1、生成随机数
	int ret = rand();
	printf("%d\n", ret);
    
	// 2、猜数字
	int guess_num = 0;
}

int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));// 要给srand传递一个变化的值，计算机上的时间是时刻发生变化的
	// time函数可以返回一个时间戳
	do
	{
		// 打印菜单
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			// printf("猜数字游戏\n");
			game();
			break;
		case 0:
			printf("退出游戏！\n");
			break;
		default:
			printf("输入错误！\n");
			break;
		}
	} while (input);

	return 0;
}

就会发现，不管摁多快，生成的随机数，都很随机。

但是，电脑生成的随机数可能太大了，我们猜数字的话可能会猜很久。

现在我们希望生成的随机数在1~100之间，只需要更改如下：

一个数 % 100，范围一定是0~99（因为是余数），再加上1，那么范围就是1~100了。

猜数字

上面的代码只能猜1次，游戏应该是，你根据提示一直猜，直到猜对了，这一轮游戏才终止。

因此，借助while()循环：

完整代码

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// 打印菜单
void menu()
{
	printf("***********************\n");
	printf("****1.play   0.exit****\n");
	printf("***********************\n");
}

void game()
{
	// 1、生成随机数
	int ret = rand() % 100 + 1;// 范围是1~100
	// printf("%d\n", ret);

	// 2、猜数字
	int guess_number = 0;
	while (1)
	{
		printf("请猜数字：");
		scanf("%d", &guess_number);
		if (guess_number > ret)
		{
			printf("猜大了！\n");
		}
		else if (guess_number < ret)
		{
			printf("猜小了！\n");
		}
		else
		{
			printf("恭喜你，猜对了！\n");
			break;
		}
	}
}

int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));// 要给srand传递一个变化的值，计算机上的时间是时刻发生变化的
	// time函数可以返回一个时间戳
	do
	{
		// 打印菜单
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			// printf("猜数字游戏\n");
			game();
			break;
		case 0:
			printf("退出游戏！\n");
			break;
		default:
			printf("输入错误！\n");
			break;
		}
	} while (input);

	return 0;
}

4、goto 语句

4.1 goto 语句适用场景

C语言中提供了可以随意滥用的 goto 语句和标记跳转的标号。

#include <stdio.h>
int main()
{
again:
	printf("hehe\n");
	printf("hehe\n");
	printf("hehe\n");
	printf("hehe\n");

	goto again;
end:
	return 0;
}

上面这段代码会一直打印hehe。

goto 语句只能一个函数内部跳转，不能跨函数跳转的。

#include <stdio.h>
void test()
{
flag:
	printf("test\n");
}

int main()
{
	printf("hehe\n");
	goto flag;//goto 语句只能一个函数内部跳转，不能跨函数跳转的
	return 0;
}

从理论上 goto语句是没有必要的，实践中没有goto语句也可以很容易的写出代码。

但是某些场合下goto语句还是用得着的，最常见的用法就是终止程序在某些深度嵌套的结构的处理过程。

例如：一次跳出两层或多层循环。

多层循环这种情况使用break是达不到目的的。它只能从最内层循环退出到上一层的循环。

goto语言真正适合的场景如下：

for(...)
    for(...)
    {
        for(...)
        {
            if(disaster)
                goto error;
        }
    }
    ......
error:
 if(disaster)
     // 处理错误情况

下面是使用goto语句的一个例子，然后使用循环的实现方式替换goto语句：

4.2 一个关机程序

#include <stdio.h>
#include <stdlib.h>
int main()
{
	char input[10] = { 0 };
	system("shutdown -s -t 60");// windows的关机命令：这表示在60s后关机
again:
	printf("电脑将在1分钟内关机，如果输入：我是猪，就取消关机!\n请输入:>");
	scanf("%s", input);
	if (0 == strcmp(input, "我是猪"))
	{
		system("shutdown -a");
	}
	else
	{
		goto again;
	}
	return 0;
}

而如果不适用goto语句，则可以使用循环：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	char input[10] = { 0 };
	system("shutdown -s -t 60");
	while (1)
	{
		printf("电脑将在1分钟内关机，如果输入：我是猪，就取消关机!\n请输入:>");
		scanf("%s", input);
		if (0 == strcmp(input, "我是猪"))
		{
			system("shutdown -a");
			break;
		}
	}
	return 0;
}

补充：

关于shutdown命令的扩展