分支和循环语句(超详解)

小灰灰 2023-10-13 18:57 30阅读 0赞

#### 分支和循环语句 ####

*   *  1.什么是语句?
     *  2.分支语句
     *   *  2.1 if语句
         *   *  2.1.1 悬空else
             *  2.1.2 if书写形式对比
             *  2.1.3 练习
         *  2.2 switch语句
         *   *  2.2.1 switch语句中的break
             *  2.2.2 default语句
             *  2.2.3 练习
     *  3. 循环语句
     *   *  3.1 while循环
         *   *  3.1.1 while循环中的continue和break
         *  3.2 for循环
         *   *  3.2.1 语法
             *  3.2.2 continue和break在for循环中
             *  3.2.3 for语句的循环控制变量
             *  3.2.4 一些for循环变种
         *  3.3 do...while（）循环
         *   *  3.3.1 do语句·语法
             *  3.3.2 执行流程
         *  3.3.3 do语句的特点
         *  3.3.4 do while循环中的continue和break
     *  循环语句案例：
     *  4.goto语句

分支语句

>  *  if
>  *  switch

循环语句

>  *  while
>  *  for
>  *  do while

goto语句

### 1.什么是语句? ###

C语句可分为以下五类：

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

部分语句代码展示：

#include <stdio.h>
    
    int main()
    {
        
    
    	3 + 5;//表达式语句
    	printf("hehe\n");//函数调用语句
    	;//空语句 - 有时候我们需要一条语句，但是这条语句什么都不需要做，就可以使用空语句
    
    	return 0;
    }

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

> 1.  条件判断语句也叫分支语句：if语句、switch语句；
> 2.  循环执行语句：do while语句、while语句、for语句；
> 3.  转向语句：break语句、goto语句、continue语句、return语句。

### 2.分支语句 ###

如果你好好学习，校招时拿一个好offer，走上人生巅峰。  
如果你不学习，毕业等于失业，回家卖红薯。  
这就是选择！  
![在这里插入图片描述][edc4ec1300124ccbbb13ac6581aad71c.png]

#### 2.1 if语句 ####

那if语句的语法结构是怎么样的呢？  
**语法结构：**

int main()
    {
        
    	if (表达式)
    		语句;
    	if (表达式)
    		语句1;
    	else
    		语句2;
    	//多分支    
    	if (表达式1)
    		语句1;
    	else if (表达式2)
    		语句2;
    	else
    		语句3;
    
    	return 0;
    }

*代码演示：*

int main()
    {
        
    	//如果年龄大于等于18-成年人
    	int age = 0;
    	scanf("%d", &age);
    	if (age >= 18)
    		printf("成年人\n");
    	return 0;
    }
    
    int main()
    {
        
    	//如果年龄大于等于18-成年人,否则打印-未成年人
    	int age = 0;
    	scanf("%d", &age);
    	if (age >= 18)
    		printf("成年人\n");
    	else
    		printf("未成年人\n");
    	return 0;
    }
    
    //age<18  - 未成年
    //18~30   - 青年
    //31~50   - 中年
    //51~70   - 中老年
    //71~99   - 老年
    //>99     - 老寿星
    
    int main()
    {
        
    	int age = 0;
    	scanf("%d", &age);
    	if (age < 18)
    		printf("未成年\n");
    	else
    	{
        
    		if (age >= 18 && age <= 30)
    			printf("青年\n");
    		else
    		{
        
    			if (age >= 31 && age <= 50)
    				printf("中年\n");
    			else
    			{
        
    				if (age >= 51 && age <= 70)
    					printf("中老年\n");
    				else
    				{
        
    					if (age >= 71 && age <= 99)
    						printf("老年\n");
    					else
    						printf("老寿星\n");
    				}
    			}
    		}
    	}
    	return 0;
    }
    代码改进：
    int main()
    {
        
    	int age = 0;
    	scanf("%d", &age);
    	if (age < 18)
    		printf("未成年\n");
    	else if (age >= 18 && age <= 30)
    		printf("青年\n");
    	else if (age >= 31 && age <= 50)
    	    printf("中年\n");
    	else if (age >= 51 && age <= 70)
    		printf("中老年\n");
    	else if (age >= 71 && age <= 99)
    		printf("老年\n");
    	else
    		printf("老寿星\n");
    	return 0;
    }
    进一步改进：
    int main()
    {
        
    	int age = 0;
    	scanf("%d", &age);
    	if (age < 18)
    		printf("未成年\n");
    	else if (age <= 30)
    		printf("青年\n");
    	else if (age <= 50)
    		printf("中年\n");
    	else if (age <= 70)
    		printf("中老年\n");
    	else if (age <= 99)
    		printf("老年\n");
    	else
    		printf("老寿星\n");
    	return 0;
    }

*解释一下：*  
如果表达式的结果为真，则语句执行。  
在C语言中如何表示真假？

> 0表示假，非0表示真。

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

int main()
    {
        
    	int age = 0;
    	scanf("%d", &age);
    	if (age >= 18)
    	{
        //代码块
    		printf("成年了\n");
    		printf("谈恋爱\n");
    	}
    	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;
    }

改正：

>  *  适当的使用\{\}可以使代码的逻辑更加清楚。
>  *  代码风格很重要

#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
    if (condition) {
        
        return x;
    }
    return y;
    //代码2
    if(condition)
    {
        
        return x;
    }
    else
    {
        
       return y;
    }
    //代码3
    int num = 1;
    if(num == 5)
    {
        
        printf("hehe\n");
    }
    //代码4
    int num = 1;
    if(5 == num)//能检测出num=5赋值操作的错误
    {
        
        printf("hehe\n");
    }

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

##### 2.1.3 练习 #####

1.  判断一个数是否为奇数

int main()
    {
        
    	int n = 0;
    	scanf("%d", &n);
    	if (n % 2 == 1)
    	//if(1 == n%2)
    		printf("YES\n");
    	else
    		printf("NO\n");
    
    	return 0;
    }

1.  输出1-100之间的奇数

//案例一：
    int main()
    {
        
    	//while
    	int i = 1;
    	while (i <= 100)
    	{
        
    		if (i % 2 == 1)
    			printf("%d ", i);
    		i++;
    	}
    	return 0;
    }
    //案例2：
    int main()
    {
        
    	//while
    	int i = 1;
    	while (i <= 100)
    	{
        
    		printf("%d ", i);
    		i = i + 2;//i+=2;
    	}
    	return 0;
    }

#### 2.2 switch语句 ####

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

> 输入1，输出星期一  
> 输入2，输出星期二  
> 输入3，输出星期三  
> 输入4，输出星期四  
> 输入5，输出星期五  
> 输入6，输出星期六  
> 输入7，输出星期日

那我没写成 if…else if …else if 的形式太复杂，那我们就得有不一样的语法形式。  
这就是switch 语句。

> switch(整型表达式)  
> \{  
> 语句项；  
> \}

而语句项是什么呢？

> //是一些case语句：  
> //如下：  
> case 整形常量表达式:  
> 语句;

##### 2.2.1 switch语句中的break #####

在switch语句中，我们没办法直接实现分支，搭配break使用才能实现真正的分支。  
比如：  
![在这里插入图片描述][24feb33cfd6f4fd2aaf2635626cf05f4.png]  
作出修改：每条语句后加上break：

int main()
    {
        
    	int day = 0;
    	scanf("%d", &day);//4
    	switch (day)
    	{
        
    	case 1:
    		printf("星期1\n");
    		break;
    	case 2:
    		printf("星期2\n");
    		break;
    	case 3:
    		printf("星期3\n");
    		break;
    	case 4:
    		printf("星期4\n");
    		break;
    	case 5:
    		printf("星期5\n");
    		break;
    	case 6:
    		printf("星期6\n");
    		break;
    	case 7:
    		printf("星期天\n");
    		break;
    	}
    	return 0;
    }

运行结果：  
![在这里插入图片描述][76510abfbe004bad82a35677983484cc.png]

有时候我们的需求变了：

> 1.  输入1-5，输出的是“weekday”;
> 2.  输入6-7，输出“weekend”

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

int main()
    {
        
    	int day = 0;
    	scanf("%d", &day);//4
    	switch (day)
    	{
        
    	case 1:
    	case 2:
    	case 3:
    	case 4:
    	case 5:
    		printf("weekday\n");
    		break;
    	case 6:
    	case 7:
    		printf("weekend\n");
    		break;
    	default:
    		printf("选择错误\n");
    		break;
    	}
    	return 0;
    }

运行结果：  
![在这里插入图片描述][1511398188384d05beaa510c93f86a8d.png]

**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;
    		}
    	case 4:
    		m++;
    		break;
    	default:
    		break;
    	}
    	printf("m = %d,n = %d\n", m, n);
    	return 0;
    }

案例结果：  
![在这里插入图片描述][d4f685e839cf469dac71a3cb4832ba02.png]

### 3. 循环语句 ###

*  while
 *  for
 *  do while  
    ![在这里插入图片描述][c82301ada6034d34b2a830ef59c69a59.png]

#### 3.1 while循环 ####

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

> if(条件)  
> 语句;

当条件满足的情况下，if语句后的语句执行，否则不执行。  
但是这个**语句只会执行一次。**

由于我们发现生活中很多的实际的例子是：同一件事情我们需要完成很多次。  
那我们怎么做呢？  
C语言中给我们引入了： **while 语句**，可以实现循环。

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

while语句执行流程：  
![在这里插入图片描述][a0b275757d29411b8cab9d1600e207dc.png]  
比如我们实现：

> 在屏幕上打印1-10的数字

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

运行结果：  
![在这里插入图片描述][caae34661df444faa4ef460dd6f0e6c4.png]

##### 3.1.1 while循环中的continue和break #####

**continue介绍**  
代码案例

int main()
    {
        
    	int i = 1;
    	while (i <= 10)
    	{
        
    		i++;
    		if (i == 5)
    			continue;
    
    		printf("%d ", i);
    	}
    
    	return 0;
    }

![在这里插入图片描述][72cfe5d6f5dc42e2b987a8d682cf2e30.png]  
***总结:***  
continue在while循环中的作用就是：

> continue是用于终止本次循环的，也就是本次循环中continue后边的代码不会再执行，

break介绍：

代码案例：

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

运行结果：  
![在这里插入图片描述][dae0df66907a4345aeb8e43862c99d62.png]  
***总结：***  
break在while循环中的作用：

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

***补：*** getchar和putchar

>  *  getchar() - 获取（输入）一个字符
>  *  getchar 读取字符成功的时候，返回字符的ASCII码值
>  *  读取失败或者遇到文件末尾的时候就返回EOF
>  *  putchar() - 输出一个字符

代码演示：  
案例一

int main()
    {
        
    	int ch = getchar();
    	printf("%c\n", ch);
    
    	return 0;
    }

运行结果：  
![在这里插入图片描述][6ca20254bea745cb86eae554a39e2de2.png]  
只能输入一次字符，如何多次输入呢？  
案例二：

int main()
    {
        
    	int ch = 0;
    	
    	while ((ch = getchar()) != EOF)
    	{
        
    		putchar(ch);
    	}
    	return 0;
    }

运行结果：  
![在这里插入图片描述][4018b8cebb5542feb85c30c5d273abeb.png]

>  *  windows 环境按ctrl+z getchar 返回EOF

案例三：只输出0…9的ASCII

int main()
    {
        
    	int ch = 0;
    	while ((ch = getchar()) != EOF)
    	{
        
    		if (ch < '0' || ch > '9')
    			continue;
    
    		putchar(ch);
    	}
    	return 0;
    }

运行结果：  
![在这里插入图片描述][f912a1aca364419c8d4eac0bced19649.png]

案例四：

int main()
    {
        
    	char password[20];
    	printf("请输入密码:>");
    	scanf("%s", password);//scanf函数在读取字符串的时候，遇到空格就不再读取
    	int ch = 0;
    	while (getchar() != '\n')
    	{
        
    		;
    	}
    	printf("请确认(Y/N):");
    	ch = getchar();
    
    	if ('Y' == ch)
    		printf("确认成功\n");
    	else
    		printf("确认失败\n");
    
    	return 0;
    }

#### 3.2 for循环 ####

我们已经知道了while循环，但是我们为什么还要一个for循环呢？  
首先来看看for循环的语法

##### 3.2.1 语法 #####

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

**表达式1**  
表达式1为初始化部分，用于初始化循环变量的。  
**表达式2**  
表达式2为条件判断部分，用于判断循环时候终止。  
**表达式3**  
表达式3为调整部分，用于循环条件的调整。

实际的问题：

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

int main()
    {
        
    	int  i = 0;
    	for (i = 1; i <= 10; i++)
    		printf("%d ", i);
    	return 0;
    }

![在这里插入图片描述][792a173407bd4eb3a303234a7bfda859.png]

for循环的执行流程图：  
![在这里插入图片描述][3fdb7b3c86404076b55fb7d6936d7ed8.png]  
对比for和while:

int i = 0;
    //实现相同的功能，使用while
    i=1;//初始化部分
    while(i<=10)//判断部分
    {
        
        printf("hehe\n");
        i = i+1;//调整部分
    }
    //实现相同的功能，使用for
    for(i=1; i<=10; i++)
    {
        
        printf("hehe\n");
    }

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

##### 3.2.2 continue和break在for循环中 #####

> 在for循环中，如果遇到continue，会跳过continue后边的代码，直接去循环的调整部分  
> 和while循环中的continue有些区别的

代码演示：

int main()
    {
        
    	int  i = 0;
    
    	for (i = 1; i <= 10;
    	{
        
    		if (i == 5)
    			continue;
    
    		printf("%d ", i)
    	}
    	return 0;
    }

运行结果：  
![在这里插入图片描述][e96b99b226524874ad740685fddda88a.png]

> break在for循环中也是直接终止循环，只要遇到break，循环就直接结束  
> break在while循环和for循环中一样

代码演示：

int main()
    {
        
    	int  i = 0;
    	for (i = 1; i <= 10; i++)
    	{
        
    		if (i == 5)
    			break;
    		printf("%d ", i);
    	}
    	return 0;
    }

运行结果：  
![在这里插入图片描述][a5c8589958fe44e0a64e09f955d0cbb8.png]  
补：  
观查以下代码：

代码一：
    int main()
    {
        
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
        
    			printf("%d ", i);
    	}
    	return 0;
    }
    
    代码二：
    int main()
    {
        
    	//C99 
    	for (int i = 0; i < 10; i++)
    	{
        
    		printf("%d\n", i);
    	}
    	printf("i = %d\n", i);
    	return 0;
    }

代码二运行结果：  
![在这里插入图片描述][40e745b7b43846888281913dab787cac.png]

> 对比代码一二，可知二不可打印i的值

##### 3.2.3 for语句的循环控制变量 #####

**建议：**

> 1.  不可在for 循环体内修改循环变量，防止 for 循环失去控制。
> 2.  建议for语句的循环控制变量的取值采用“前闭后开区间”写法

int main()
    {
        
    	int arr[10] = {
         1,2,3,4,5,6,7,8,9,10 };
    	//0~9
    	int i = 0;
    	for (i = 0; i < 10; i++)//[0,10)
    	{
        
    		printf("%d ", arr[i]);
    	}
    
    	//for (i = 0; i <= 9; i++)//[0,9]
    	//{
        
    	//	printf("%d ", arr[i]);
    	//}
    	//return 0;
    }

##### 3.2.4 一些for循环变种 #####

案例一：

#include <stdio.h>
    int main()
    {
        
     //代码1
     for(;;)
     {
        
     printf("hehe\n");
     }

> for循环中的初始化部分，判断部分，调整部分是可以省略的，但是不建议初学时省略，容易导致问  
> 题。

案例二：

int main()
    {
        
    	int i = 0;
    	int j = 0;
    	//这里打印多少个hehe?
    	for (i=0; i < 3; i++)
    	{
        
    		for (j=0; j < 3; j++)
    		{
        
    			printf("hehe\n");
    		}
    	}
    	return 0;
    }

运行结果：  
![在这里插入图片描述][5eebc6e44ca642c595fa308ee78115af.png]

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

运行结果：  
![在这里插入图片描述][e842399ec85440c7b4c039c2d43d873f.png]  
案例三：

//代码4-使用多余一个变量控制循环
     int x, y;
        for (x = 0, y = 0; x<2 && y<5; ++x, y++)
       {
        
            printf("hehe\n");
       }
     return 0;
    }

运行结果：  
![在这里插入图片描述][47432ce2dafa4c59a951940225d2823d.png]

#### 3.3 do…while（）循环 ####

##### 3.3.1 do语句·语法 #####

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

##### 3.3.2 执行流程 #####

![在这里插入图片描述][c3d49faab4124567a80b9018fa275ade.png]

#### 3.3.3 do语句的特点 ####

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

代码演示：

int main()
    {
        
    	int i = 10;
    	do
    	{
        
    		printf("%d\n", i);
    	} while (i < 10);
    	return 0;
    }

运行结果：  
![在这里插入图片描述][17b4040616164206b9dc3031dcf71aac.png]

#### 3.3.4 do while循环中的continue和break ####

>  *  do while循环中break和continue和在while循环中一模一样
>  *  break都是用于终止循环，continue是跳过本次循环后边的代码，直接去判断部分

代码演示;

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

运行结果：  
![在这里插入图片描述][bfc2c8c40fd84d7bade588a8c367aea9.png]

--------------------

### 循环语句案例： ###

--------------------

案例一：计算n阶乘

//5!= 1*2*3*4*5 = 120
    //2!= 1*2
    int main()
    {
        
    	int n = 0;
    	scanf("%d", &n);
    	//循环产生1~n的数字
    	int i = 0;
    	int ret = 1;
    	for (i = 1; i <= n; i++)
    	{
        
    		//ret = ret * i;
    		ret *= i;
    	}
    	printf("%d\n", ret);
    	return 0;
    }

案例二：计算 1!+2!+3!+……+10!

int main()
    {
        
    	int n = 0;
    	//循环产生1~n的数字
    	int i = 0;
    	int ret = 1;
    	int sum = 0;
    	//1!+2!+3! = 1 + 2 + 6 = 9
    	//1*1
    	//1*1*2
    	//1*1*2*3
    	//1*1*2*3*4
    	//1*1*2*3*4*5
    	for (n = 1; n <= 10; n++)
    	{
        
    		ret = 1;
    		for (i = 1; i <= n; i++)
    		{
        
    			ret *= i;
    		}
    		sum += ret;
    	}
    	printf("%d\n", sum);
    }
    //进行优化：
    int main()
    {
        
    	int n = 0;
    	//循环产生1~n的数字
    	int i = 0;
    	int ret = 1;
    	int sum = 0;
    	//1!+2!+3! = 1 + 2 + 6 = 9
    	//1*1
    	//1*1*2
    	//1*1*2*3
    	//1*1*2*3*4
    	//1*1*2*3*4*5
    	for (n = 1; n <= 10; n++)
    	{
        
    		ret *= n;
    		sum += ret;
    	}
    	printf("%d\n", sum);
    	return 0;
    }

案例三：在一个有序数组中查找具体的某个数字n。

//1 2 3 4 5 6 7 8 9 10
    //0 1 2 3 4 5 6 7 8 9
    //7
    int main()
    {
        
    	int arr[10] = {
         1,2,3,4,5,6,7,8,9,10 };
    	int k = 0;
    	scanf("%d", &k);//7
    	//遍历
    	int i = 0;
    	int flag = 0;
    	for (i = 0; i < 10; i++)
    	{
        
    		if (arr[i] == k)
    		{
        
    			printf("找到了，下标是:%d\n", i);
    			flag = 1;
    			break;
    		}
    	}
    	if (flag == 0)
    		printf("找不到\n");
    	return 0;
    }

优化：折半查找（二分查找）

int main()
    {
        
    	int arr[] = {
         1,2,3,4,5,6,7,8,9,10 };
    	//printf("%d\n", sizeof(arr));//40 - 数组的总大小，单位是字节
    	//printf("%d\n", sizeof(arr[0]));
    	//printf("%d\n", sizeof(arr)/sizeof(arr[0]));//
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	int k = 0;
    	scanf("%d", &k);
    	int left = 0;
    	int right = sz-1;
    	int flag = 0;
    	while (left<=right)
    	{
        
    		int mid = (left + right) / 2;
    		if (arr[mid] < k)
    			left = mid + 1;
    		else if (arr[mid] > k)
    			right = mid - 1;
    		else
    		{
        
    			printf("找到了，下标是：%d\n", mid);
    			flag = 1;
    			break;
    		}
    	}
    	if (flag == 0)
    		printf("找不到了\n");
    	return 0;
    }

案例四：编写代码，演示多个字符从两端移动，向中间汇聚

//welcome to bit!!!!!!!
    //*********************
    //w*******************!
    //we*****************!!
    //wel***************!!!
    //...
    //welcome to bit!!!!!!!
    #include <string.h>
    #include <windows.h>
    int main()
    {
        
    	char arr1[] = "welcome to bit!!!!!!!";
    	char arr2[] = "*********************";
    	//char arr[] = "abc";
    	//a b c \0
    	//0 1 2
    	//strlen(arr) - 3
    	//sizeof(arr)/sizeof(arr[0]);
    	//4-2
    	int left = 0;
    	int right = strlen(arr2) - 1;
    	while (left<=right)
    	{
        
    		arr2[left] = arr1[left];
    		arr2[right] = arr1[right];
    		printf("%s\n", arr2);
    		Sleep(1000);
    		system("cls");//清空屏幕
    		left++;
    		right--;
    	}
    	printf("%s\n", arr2);
    	return 0;
    }

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

//"123456"
    //strcmp 函数是比较字符串的大小的,头文件string.h
    //>   >0
    //==  0
    //<   <0
    #include <string.h>
    int main()
    {
        
    	int i = 0;
    	char password[20] = {
        0};
    	for (i = 0; i < 3; i++)
    	{
        
    		printf("请输入密码:>");
    		scanf("%s", password);
    		if (strcmp(password, "123456") == 0)
    		{
        
    			printf("登录成功\n");
    			break;
    		}
    		else
    		{
        
    			printf("密码错误\n");
    		}
    	}
    	if (i == 3)
    		printf("三次密码错误，退出程序\n");
    	return 0;
    }

案例六：猜数字游戏实现

//电脑随机生产一个1~100之间的数
    //接下来我们猜数字
    //如果猜小了，就告诉你猜小了
    //如果猜大了，就告诉你猜大了
    //如果猜对了，那就恭喜你，游戏结束
    //
    #include <stdlib.h>
    #include <time.h>
    void menu()
    {
        
    	printf("**************************\n");
    	printf("******  1. play     ******\n");
    	printf("******  0. exit     ******\n");
    	printf("**************************\n");
    }
    void game()
    {
        
    	//1. 生成1~100的随机数
    	//rand函数生产的伪随机数
    	//rand函数生产的随机数的范围是：0~RAND_MAX(32767)
    	//rand函数在生产随机数之前，要使用srand函数设置随机数的生成器
    	int ret = rand()%100+1;//0~99+1 --> 1~100
    	printf("%d\n", ret);
    	//RAND_MAX;
    	
    	//2. 猜数字
    	int guess = 0;
    	while (1)
    	{
        
    		printf("请猜数字:>");
    		scanf("%d", &guess);
    		if (guess < ret)
    			printf("猜小了\n");
    		else if (guess > ret)
    			printf("猜大了\n");
    		else
    		{
        
    			printf("恭喜你，猜对了\n");
    			break;
    		}
    	}
    }
    
    //邮戳
    //time - 函数可以返回一个时间戳
    
    int main()
    {
        
    	int input = 0;
    	srand((unsigned int)time(NULL));
    	do
    	{
        
    		menu();
    		printf("请选择>:");
    		scanf("%d", &input);
    		switch (input)
    		{
        
    		case 1:
    			game();
    			break;
    		case 0:
    			printf("退出游戏\n");
    			break;
    		default:
    			printf("选择错误，重新选择\n");
    			break;
    		}
    	} while (input);
    	return 0;
    }

### 4.goto语句 ###

> C语言中提供了可以随意滥用的 goto语句和标记跳转的标号。  
> 从理论上 goto语句是没有必要的，实践中没有goto语句也可以很容易的写出代码。  
> 但是某些场合下goto语句还是用得着的，最常见的用法就是终止程序在某些深度嵌套的结构的处理过  
> 程。

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

for(...)
        for(...)
       {
        
            for(...)
           {
        
                if(disaster)
                    goto error;
           }
       }
        …
    error:
     if(disaster)

> 不能跨函数跳转：

代码演示：

void test()
    {
        
    flag:
    	printf("haha\n");
    
    }
    int main()
    {
        
    	printf("hehe\n");
    	goto flag;//err-goto 只能在同一个函数内部跳转，不能跨函数
    	return 0;
    }

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

//关机程序
    
    //程序运行起来后，1分钟内关机
    //如果，输入：我是猪，就取消关机
    
    int main()
    {
        
    	char input[20] = {
         0 };
    	system("shutdown -s -t 60");//开始倒计数关机
    
    again:
    	printf("你的电脑在1分钟内就会关机，如果输入：我是猪，就取消关机\n");
    	scanf("%s", input);
    	if (strcmp(input, "我是猪") == 0)
    	{
        
    		system("shutdown -a");
    		printf("你很配合，已经取消关机\n");
    	}
    	else
    	{
        
    		goto again;
    	}
    	return 0;
    }

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

int main()
    {
        
    	char input[20] = {
         0 };
    	system("shutdown -s -t 60");//开始倒计数关机
    
    	while (1)
    	{
        
    		printf("你的电脑在1分钟内就会关机，如果输入：我是猪，就取消关机\n");
    		scanf("%s", input);
    		if (strcmp(input, "我是猪") == 0)
    		{
        
    			system("shutdown -a");
    			printf("你很配合，已经取消关机\n");
    			break;
    		}
    	}
    	return 0;
    }

本次内容来到了尾声，相信阅读本次内容的你收获满满。期待下次文章与大家见面！！！

[edc4ec1300124ccbbb13ac6581aad71c.png]: https://img-blog.csdnimg.cn/edc4ec1300124ccbbb13ac6581aad71c.png
[24feb33cfd6f4fd2aaf2635626cf05f4.png]: https://img-blog.csdnimg.cn/24feb33cfd6f4fd2aaf2635626cf05f4.png
[76510abfbe004bad82a35677983484cc.png]: https://img-blog.csdnimg.cn/76510abfbe004bad82a35677983484cc.png
[1511398188384d05beaa510c93f86a8d.png]: https://img-blog.csdnimg.cn/1511398188384d05beaa510c93f86a8d.png
[d4f685e839cf469dac71a3cb4832ba02.png]: https://img-blog.csdnimg.cn/d4f685e839cf469dac71a3cb4832ba02.png
[c82301ada6034d34b2a830ef59c69a59.png]: https://img-blog.csdnimg.cn/c82301ada6034d34b2a830ef59c69a59.png
[a0b275757d29411b8cab9d1600e207dc.png]: https://img-blog.csdnimg.cn/a0b275757d29411b8cab9d1600e207dc.png
[caae34661df444faa4ef460dd6f0e6c4.png]: https://img-blog.csdnimg.cn/caae34661df444faa4ef460dd6f0e6c4.png
[72cfe5d6f5dc42e2b987a8d682cf2e30.png]: https://img-blog.csdnimg.cn/72cfe5d6f5dc42e2b987a8d682cf2e30.png
[dae0df66907a4345aeb8e43862c99d62.png]: https://img-blog.csdnimg.cn/dae0df66907a4345aeb8e43862c99d62.png
[6ca20254bea745cb86eae554a39e2de2.png]: https://img-blog.csdnimg.cn/6ca20254bea745cb86eae554a39e2de2.png
[4018b8cebb5542feb85c30c5d273abeb.png]: https://img-blog.csdnimg.cn/4018b8cebb5542feb85c30c5d273abeb.png
[f912a1aca364419c8d4eac0bced19649.png]: https://img-blog.csdnimg.cn/f912a1aca364419c8d4eac0bced19649.png
[792a173407bd4eb3a303234a7bfda859.png]: https://img-blog.csdnimg.cn/792a173407bd4eb3a303234a7bfda859.png
[3fdb7b3c86404076b55fb7d6936d7ed8.png]: https://img-blog.csdnimg.cn/3fdb7b3c86404076b55fb7d6936d7ed8.png
[e96b99b226524874ad740685fddda88a.png]: https://img-blog.csdnimg.cn/e96b99b226524874ad740685fddda88a.png
[a5c8589958fe44e0a64e09f955d0cbb8.png]: https://img-blog.csdnimg.cn/a5c8589958fe44e0a64e09f955d0cbb8.png
[40e745b7b43846888281913dab787cac.png]: https://img-blog.csdnimg.cn/40e745b7b43846888281913dab787cac.png
[5eebc6e44ca642c595fa308ee78115af.png]: https://img-blog.csdnimg.cn/5eebc6e44ca642c595fa308ee78115af.png
[e842399ec85440c7b4c039c2d43d873f.png]: https://img-blog.csdnimg.cn/e842399ec85440c7b4c039c2d43d873f.png
[47432ce2dafa4c59a951940225d2823d.png]: https://img-blog.csdnimg.cn/47432ce2dafa4c59a951940225d2823d.png
[c3d49faab4124567a80b9018fa275ade.png]: https://img-blog.csdnimg.cn/c3d49faab4124567a80b9018fa275ade.png
[17b4040616164206b9dc3031dcf71aac.png]: https://img-blog.csdnimg.cn/17b4040616164206b9dc3031dcf71aac.png
[bfc2c8c40fd84d7bade588a8c367aea9.png]: https://img-blog.csdnimg.cn/bfc2c8c40fd84d7bade588a8c367aea9.png