经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C 语言 » 查看文章
分支与循环 - L-wk
来源：cnblogs　　作者：L-wk　　时间：2021/12/17 14:28:55　　对本文有异议

分支与循环

这章节我们会讲到以下几个知识：

  1. 分支语句

    • if
    • switch

  2. 循环语句

    • while循环
      - for循环
      - do...while循环

  3. goto语句

还是那句话，我只是一个刚入门的小菜鸟，哪有有讲的不好，还望大家海涵。

先讲一个知识点，在C语言中什么是语句呢？C语言中由一个分号;隔开的就是一条语句。比如：

  1. #include <stdio.h>
  2. int main ()
  3. {
  4.     1+2;//这是一条语句
  5.     printf("Hello\n");//这也是一条语句
  6.     ;//这也是一条语句
  7.     return 0;
  8. }

在C语言中所有语句都分为三大类型：

  1. 顺序结构
  2. 选择结构
  3. 循环结构

顺序结构很简单，程序从上至下地执行，中间无任何判断和跳转。流程示意图：

下面的我就没继续画了，大家懂就可以了。而下面重点要讲的是分支与循环结构。

分支语句（选择语句）

分支语句也称选择语句，什么叫选择呢？就好比在大学里，如果好好学习，校招时就拿一个好offer。如果不好好学习，那就回家种田吧。而学不学呢就是一种选择。

我画的图描述的清楚吗？各位客官？分支语句也分为以下几种：

  • if语句
  • switch语句

if语句

if语句，if是啥意思？如果的意思。那相对应的是不是还有else否则的意思？那我们看看if语句在C语言中是怎样描述的呢？

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

解释：就是如果表达式结构为真就执行语句1反之执行语句2，if(表达式)表达式为真就执行if后面的语句，如果为假就执行else后的语句。那有人就问了在C语言中怎样描述真假的呢？

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

举个例子吧，如果if(1>2)，这个表达式的结果是什么？1会大于2吗？显然是不会的所以这个表达式的结果为假也就是0。

用代码形式来讲吧：

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     int  age = 9;
  5.     if(age<18)
  6.     {
  7.         printf("未成年\n");
  8.     }
  9.     return 0;
  10. }
  11. //代码2
  12. int main()
  13. {
  14.     int age = 18;
  15.     if(age>=18)
  16.     {
  17.         printf("成年人\n");
  18.     }
  19.     else
  20.     {
  21.         printf("未成年\n");
  22.     }
  23.     return 0;
  24. }
  25. //代码3
  26. int main()
  27. {
  28.     int age = 25;
  29.     if(age<18)
  30.     {
  31.         printf("未成年\n");
  32.     }
  33.     else if(age>=18&&age<30)
  34.     {
  35.         printf("青年");
  36.     }
  37.     else if(age>=30&&age<55)
  38.     {
  39.         printf("中年\n");
  40.     }
  41.     else
  42.     {
  43.         printf("老年人");
  44.     }
  45.     return 0;
  46. }

看看效果吧：

image-20211214160305104

效果果然跟预想的是一样的，有人有点好奇为啥要加大括号呢？我们看看下面：

image-20211214160434074

我们看到报错了，为啥呢？那为啥下面没错呢？

image-20211214160501686

if语句默认只能控制一条语句所以程序报错。因为在C语言中，if和else不加括号默认控制一条语句，我们可以试试：

image-20211214160820896

看到虽然没有报错，但是它多打印了一条语句，再换一个：

image-20211214160911228

可以知道确实if语句和else语句默认只能控制一条语句。我们可以加上大括号来防止这些错误。

接着我们看代码3的运行效果：

image-20211212174402046

年龄大家可以自行修改，或者加入一条输入语句，自己输入想要判断的年龄，代码3是属于if语句中的多分支语句，也就是有多重选择，如果怎么怎么样会怎么怎么样，又如果怎么怎么样又会怎么怎么样，..........最后否则怎么样。这是属于if语句的知识点。

我们检测一下：

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

想想结果是啥？是hello还是heihei呢？咱们看看运行效果：

image-20211214160947677

啥也没输出，为什么呢？这涉及到一个知识点：

if语句中if会与最近的else进行配对

所以这题具体的意思就是：

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     int a = 0;
  5.     int b = 2;
  6.     if(a==1)
  7.         if(b==2)
  8.             printf("hello\n");
  9.         else
  10.         	printf("heihei\n");
  11.     return 0;
  12. }
  13. //也等于
  14. if(a==1)
  15. {
  16.     if(b==2)
  17.     {
  18.         printf("hello\n");
  19.     }
  20.     else
  21.     {
  22.         printf("heihei\n");
  23.     }
  24. }
  25. //或者想打印heihei这样改造
  26. int main()
  27. {
  28.     int a = 0;
  29.     int b = 2;
  30.     if(a==1)
  31.     {  
  32.         if(b==2)
  33.         {
  34.             printf("hello\n");
  35.         }
  36.     }
  37.     else
  38.     {
  39.         printf("heihei\n");
  40.     }	
  41.     return 0;
  42. }

第一个判断是否成立呢？0会等于1嘛？肯定不会的，也没有想匹配的else语句所以啥也不会输出。所以大家要注意哦，书写规范还是挺重要的，当然知识点也不能忘掉。我们再看两段代码：

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     int n = 5;
  5.     if(n==7)
  6.     {
  7.         printf("hello");
  8.     }
  9.     return 0;
  10. }
  11. //代码2
  12. int main()
  13. {
  14.     int n = 5;
  15.     if(7==n)
  16.     {
  17.         printf("hello");
  18.     }
  19.     return 0;
  20. }

这两段代码各位觉得如何？个人觉得代码2要更好，更严谨，如果我们代码1的形式少了个=号，会怎么样？

image-20211214161204751

确实是正常运行的，但是n的值被改变了，这可不是我们 想要的结果呀？我们换下：

image-20211214161103080

如果我们换一种写法，就直接报错了，所以这种写法还是严谨的。逻辑更加清晰，不容易出错。

练习:

  1. 判断一个数是否为奇数
  2. 输出1~100之间的奇数
  1. #include <stdio.h>
  2. int main()
  3. {
  4.     int n = 5;
  5.     if(n%2!=)
  6.     {
  7.         printf("奇数\n");
  8.     }
  9.     else
  10.     {
  11.         printf("偶数\n");
  12.     }
  13.     return 0;
  14. }
  15. //2
  16. int main()
  17. {
  18.    int i = 1;
  19.     while(i<=100)
  20.     {
  21.         if(i%2!=0)
  22.         {
  23.             printf("%d ",i);
  24.         }
  25.         i++;
  26.     }
  27. }

Switch语句

我们再讲分支语句中另外一大分支语句 -- Switch语句。Switch语句用于多分支的情况。比如说输入1~7中的任意数字，然后输出相对应的日期。

输入1，输出星期一

输入2，输出星期二

.....

输入7，输出星期日

虽然我们使用if..else if ...else if....else的形式可以完成要求，但是太复杂了，代码会过于冗余也就是太长了，这个时候我们就可以用Switch语句。

  1. switch (整型表达式)
  2. {
  3.     case 整型常量:
  4.         语句;
  5.         break;
  6.     case 整型常量2:
  7.         语句;
  8.         break;
  9.         //.....
  10.     default:
  11.         语句;
  12.         break;
  13. }

我们用上面的例子：

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     int day = 0;
  5.     scanf("%d",&day);
  6.     switch(day)
  7.     {
  8.         case 1:
  9.             printf("星期一\n");
  10.             break;
  11.         case 2:
  12.             printf("星期二\n");
  13.             break;
  14.         case 3:
  15. 			printf("星期三\n");
  16.             break;
  17.         case 4:
  18.             printf("星期四\n");
  19.             break;
  20.         case 5:
  21.             printf("星期五\n");
  22.             break;
  23.         case 6:
  24.             printf("星期六\n");
  25.             break;
  26.         case 7:
  27.             printf("星期日\n");
  28.             break;
  29.         default:
  30.             printf("输入错误\n");
  31.             break;
  32.     }
  33.     return 0;
  34. }

效果如下:

image-20211214161639543

这里用英语的形式是因为鄙人正在学习英语哈，勿怪勿怪。

看了效果后，带大家理解理解这玩意，Switch(整型表达式)这里只能是整型或者字符型，因为字符型其实也是整型的一种嘛，然后case后面也必须跟的是整型常量值，这是规定，别问我我也不大了解。至于每条语句为啥加了break呢？break是什么意思呢？break在英语中是打破、弄坏、停止运转的意思，那么在计算机中又是啥意思呢？在初始C语言中，我们也知道这个break是关键字，在C语言中break是指跳出，结束的意思。就是跳出程序的意思，我们试着把这个去掉看看：

image-20211214161726304

咋一看全打印出来了，为啥呢？就是因为少了跳出的关键字，我们加上一个试试：

image-20211214161751630

我们加上一条break语句后，确实后面的没有打印了，可是我们输入的是1呀，应该只会输出一个呀？因为只有一个break语句，所以我们为了应对要求所以应该在每条case语句后加上break，这样就可得到之前的效果。注意看我还输入一条语句就是default语句，这个又是啥意思呢？我们看效果：

image-20211214161827498

输出的竟然是输入错误，也确实，我们生活中也没有星期八的存在呀，default是什么意思呢？默认、违约的意思，同样的在C语言中，default也是默认的意思，就是除了我们给出的几个常量值，如果我输入的值不在这几个之内，那么我们就可以用这个语句提醒用户输入是错误的。这是一个好的编程习惯，这样我们可以总结出几个编程习惯:

  • 在case 语句的后面加上一条 break语句。
  • 按要求来给每个case语句加break语句。
  • 在每个 switch 语句中都放一条default子句是个好习惯，甚至可以在后边再加一个 break 。

break语句可以把语句列表划分成不同的部分。比如1 ~ 5都是工作日，6 ~ 7是休息日。

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     int day = 0;
  5.     scanf("%d",&day);
  6.     switch(day)
  7.     {
  8.         case 1:
  9.         case 2:
  10.         case 3:
  11.         case 4:
  12.         case 5:
  13.             printf("weekday\n");
  14.             break;
  15.         case 6:
  16.         case 7:
  17.             printf("playday\n");
  18.             break;
  19.    		default:
  20.             break;
  21.     }
  22.     return 0;
  23. }

我们看看效果：

image-20211212205124391

因为break把1 ~ 5分为一部分，无论是输入1还是其他1~5之间的任何数输出都是weekday，同样的把6 ~7也分为一部分。

下面我们来做一道Switch嵌套Switch的练习：

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

大家思考一下是多少呢？

image-20211212195753579

大家看到m=5,n=3，为什么呢？解析：

  1. int n = 1;
  2. int m = 2;
  3. switch(1)
  4. {
  5. case 1://因为n是1所以执行case1
  6.   m++;//m=m+1 = 2+1 = 3
  7. case 2:
  8.   n++;//n=2
  9. case 3://因为上局case语句没有break语句所以会继续执行下面语句
  10.   switch(2)//n=2
  11.   {
  12.       case 1:
  13.           n++;
  14.       case 2://因为n=2所以执行的是这条语句
  15.           m++;//m=3+1=4
  16.           n++;//n=2+1=3
  17.           break;//遇到跳出语句了所以跳出这个Switch语句
  18.   }
  19. case 4:
  20.   m++;//接着上面的数据 m=4+1=5  n = 3
  21.   break;//遇到跳出语句所以跳出整个Switch语句后面的代码不再执行
  22. }

循环语句

循环语句，也就是重复的做某件事情，比如说我需要打印100行“Hello World”，虽然说可以用100条printf函数打印出来，但是也需要太长的代码了，所以我们采用循环语句来做。咱们看看流程图：

image-20211212205812551

在循环语句中又分为3中类型：

  1. while
  2. for
  3. do...while

while循环

C语言中while循环的语法规定：

  1. //while语法结构
  2. while(表达式)
  3. {
  4.     循环语句;//循环体
  5. }
  6. int i = 0;//初始化
  7. while(i<10)//条件判断
  8. {
  9.     i++;//循环变量调整
  10. }

我们用流程图来说明while循环：

画的不是很好大家谅解谅解。这大概就是while循环的流程图了。我们来看看实例：

打印1~100的数字

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

效果如下:

image-20211212211347246

循环条件如果恒为真那就死循环了。在while循环也是可以使用break语句跳出循环的，比如说我遇到了20就退出循环：

image-20211212212218568

可以看到确实到了20就已经退出了循环，那我只想不要20这个数字，继续打印后面的呢？请看下面：

image-20211213084415965

可以看到确实跳过了20直接打印后面的数字了。可是数字1也没有打印出来，原因是i的值在进入循环后就发生了自增，所以直接跳过了数字1，如果想得到1也很简单，我们把i的值初始化为0即可，通过观察break和continue语句的作用，我们得出结论：

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

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

注意:

while循环嵌套continue语句时注意循环变量的增值表达式的位置，也就是上面的i++;

我们把循环变量的增值表达式放到下面来看看：

image-20211214102815334

20虽然没有打印，但是后面的21也没有打印是因为，循环变量的增值表达式放在后面进行的，一旦i等于20，就直接跳过本次循环了，后面的语句就不会执行，所以i==20不会被改变的。注意这一点。

咱们看几道练习题：

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     int c = 0;
  5.     while((c=getchar())!=EOF)
  6.     {
  7.         putchar(c);
  8.     }
  9.     return 0;
  10. }
  11. //2
  12. int main()
  13. {
  14.     int c=0;
  15.     while((c=getchar())!=EOF)
  16.     {
  17.         if(c<'0'||c>'9')
  18.         {
  19.             continue;
  20.         }
  21.         putchar(c);
  22.     }
  23. }

大家看到这两段代码是不是很陌生？getchar是是啥？getchar是获取字符的意思，也可理解为输入字符的意思，跟输入语句有点类似，那与之相对应的输出字符就是putchar，那EOF又是啥呢？EOF是end of file的缩写，也就是文件结束标志，跟字符串的‘\0’有点相似。我们看它是怎么定义的：

image-20211213091254309

使用define定义的，实际上是-1。那整段代码是什么意思呢？getchar读取失败的时候会返回EOF，如果读取字符不等于EOF就进入循环，然后打印字符。

image-20211213091737911

可以看见确实输出了我们输入的字符，那我们要怎样才能结束循环能？Ctrl+Z就可以结束了。那getchar是怎样读取字符的呢？是直接从键盘上读取吗？其实并不是，在getchar和键盘之间有一个缓冲区，程序刚开始，缓冲区是空的，需要输入数据到缓冲区，比如我们输入字符A然后回车，其实回车也算字符，回车也就是\n，所以会把字符A和\n一起放进缓冲区，然后getchar去读取字符，读取字符A放到变量c，然后在屏幕上打印字符A，这时缓冲区只剩下\n，然后getchar继续读取，读取到\n就换行了，然后此时缓冲区就空了，需要继续输入字符，这也是后面光标在闪的原因。


那代码2又是什么意思呢？我们知道了代码1是输入字符然后再打印字符，那中间加了一个判断语句，很显然就是只会打印‘0’~'9'

image-20211214101717707

判断条件是如果c小于字符0或大于字符9就跳过本次循环，因为有continue关键字嘛，所以只有输入字符0到字符9之间的任意数都可以在屏幕上打印相对应的字符。这是这两题的解析，那我们知道这种代码有什么用呢？我们看个实例：

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     char password[10]={0};
  5.     int c = 0;
  6.     printf("请输入密码:");
  7.     scanf("%s",password);
  8.     printf("请确认密码(Y/N):\n");
  9.     c = getchar();
  10.     if(c == 'Y')
  11.     {
  12.         printf("确认成功\n");
  13.     }
  14.     else
  15.     {
  16.         printf("确认失败\n");
  17.     }
  18.     return 0;
  19. }

运行结果:

image-20211214103451540

我还没开始输入确认与否呢，它直接来一句确认失败。这不玩儿呢？还记得我们之前画的那张图嘛？解析：

程序开始我们输入：123456+回车键，这就相当于在缓冲区放了123456+\n，我们输入语句scanf会把我们输入的字符串给拿走放到password里去，但是\n还在缓冲区，此时getchar就会去缓冲区里读取\n所以后面判断条件是假的。

那我们该咋办呢？

思路：既然缓冲区还有\n那我们再用一个getchar来读取这个字符

image-20211214104217518

emmmm确实是可以，但是如果我们如果输入其他字符串呢？比如说中间有空格键之类的：

image-20211214104329331

这是为啥呢？不就是加了个空格吗？这跟scanf函数有关了，scanf函数碰到空格就不会继续去字符了，这样缓冲区就还剩下空格加 123然后getchar读取一个字符空格，后面再判断，判断条件也会为假，所以程序结果如图上所示。使用了几次scanf语句，我来解释一下scanf的用法：

  1. int i = 0;
  2. scanf("%d",&i);//%d以十进制的形式输入   &i是取i的地址 &是scanf中必须要使用的 上面代码没有使用是因为数组名是数组首元素的地址使用可以不加&符号。

那我们怎样解决呢？

思路：既然getchar语句是一个一个的读取，而且我们输入之后都会按回车键（\n），那我们可以使用循环的方式来读取后面的字符，如果是\n就跳出循环，然后再判断是否需要确认密码。我们把回车给干掉。这样也相当清理缓冲区。

image-20211214105354108

如果我们在做题的时候可能会碰到类似的题目，当我们碰到这种题的时候要记住还有个缓冲区的存在。

for循环

我们已经知道while循环了，在C语言中还有个常用的另外一个循环 ---- for循环。流程图如图所示：

画的不好大家见谅哈。

首先看for循环的语法：

语法:

  1. for(表达式1;表达式2;表达式3)
  2. {
  3. 	循环语句;
  4. }
  5. //表达式1为初始化部分，用于初始化循环变量的。
  6. //表达式2为条件判断部分，用于判断循环时候终止。 
  7. //表达式3为调整部分，用于循环条件的调整。

用法：

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     int i = 0;
  5.     //  初始化  条件判断  循环变量调整
  6.     for(i = 1; i < 11; i++)
  7.     {
  8.         printf("%d ",i);
  9.     }
  10.     return 0;
  11. }

这段代码会打印出什么呢？

初始化：i = 1，条件判断：i < 11为真进入循环 循环语句： 打印1 循环变量调整： i++

i = 2 i < 11 打印2

.....

i = 10 i < 11为真 打印10 i++

i = 11 i < 11为假 不进入循环

经过分析代码，想必大家也知道这段代码会打印什么了吧。没错就是1~10。在for循环中也可以使用break和continue语句。作用都是一样的。但是continue有点不一样:

image-20211214112222769

它不会像while循环那样会出现死循环，因为它调整部分是在外边进行的，跳过里面的语句返回到上面的调整部分。

continue在for循环中跳过本次循环，后面的语句不执行，直接跳到调整部分。

for循环的循环控制变量

1.不可在for循环体内修改循环变量，防止for循环失控，造成死循环。

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

试下第一条：

image-20211214112933544

这样就造成了死循环，所以我们在使用for循环是千万不要再循环体内改变循环变量的值。

第二点是什么意思呢？我们可以使用一个数组来说明一下：

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     int arr[10]={0};
  5.     int i = 0;
  6.     for(i=0;i<10;i++)//这就是前闭后开的写法 当然也可以写成for(i=0;i<=9;i++)
  7.     {
  8.         printf("%d ",arr[i]);
  9.     }
  10.     return 0;
  11. }

前闭后开，大家应该有听说过这个数学中有学过前闭后开就是前面等于后面小于或大于的写法，比如上面的前闭后开在数学的写法就是[0,10),大于等于0小于10。虽然也可以写作前闭后闭区间，但是写成这样的形式更直观，一眼就能看出是循环多少次。

看下面代码结果是什么呢？

  1. #include <stdio.h>
  2. //1
  3. int main()
  4. {
  5.     for(;;)
  6.     {
  7.         printf("hello\n");
  8.     }
  9.     return 0;
  10. }
  11. //2.
  12. int main()
  13. {
  14.     int i,j;
  15.     for(i=0,j=0;i<3&&j<5;++i,j++)//++i或者i++都可以不影响
  16.     {
  17.         printf("hello\n");
  18.     }
  19.     return 0;
  20. }

代码1

image-20211214135907938

  • 结果是死循环打印hello
  • 虽然说for语句中初始化、条件判断、调整3部分都能省略，但是判断部分省略会导致程序死循环，因为判断部分省略会导致判断部分恒为真。
  • 除非特殊要求，否则不要省略。

再换个代码把上面改一下:

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     int i = 0;
  5.     int j = 0;
  6.     for(;i<3;i++)
  7.     {
  8.         for(;j<3;j++)
  9.         {
  10.             printf("hello\n");
  11.         }
  12.     }
  13.     return 0;
  14. }

那这样结果是什么呢？

image-20211214135755884

为什么？

i = 0; i < 3为真 ： j = 0; j < 3为真；打印hello；j++ j = 1 ; j < 3为真；打印hello; j++; j = 2;j<3为真 打印hello； j++； j = 3 ；j < 3为假 不进入循环；i++；

i = 1；i < 3为真；j = 3；j < 3为假 不进入循环。i++

....

除非要求需要，不然还是不要轻易省略for语句的三部分的任意部分。

代码2：

image-20211214140646790

  • 结果只打印3次hello
  • i = 0；j = 0； i小于3并且j小于5，条件为真进入循环打印hello
  • i = 1；j = 1；条件依然为真 打印hello
  • i = 2；j = 2；条件依然为真 打印hello
  • i = 3；j = 3；条件为假，不打印 跳出循环。
  • 初始化、判断、调整这三部分可以是一条语句也可以是多条语句。

看一道习题：

  1. //请问循环几次？
  2. #include <stdio.h>
  3. int main()
  4. {
  5.     int i = 0;
  6.     int j = 0;
  7.     for(i=0,j=0;j=0;i++,j++)
  8.         	j++;
  9.     return 0;
  10. }

循环几次呢？其实一眼就能看出，循环0次，为什么呢？因为压根儿就不会进入循环。条件判断部分是赋值，把0赋给j，然后j是0，0为假所以不会进入循环。

do...while循环

前两个循环是不是都要先判断才能进入循环，这个循环可就不一样了，它允许先执行然后再判断是否还需执行，先执行再判断。流程图：

语法

  1. do
  2. {
  3.     循环语句
  4. }while(表达式);//判断

特点

循环至少执行一次，使用场景有限制，所以很少看见do...while的使用。

使用

打印1~10:

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

image-20211214142539031

  • 该循环无论如何一上来就会打印i，然后再接着判断是否小于11，是的话就会接着执行循环。

再试试break和continue在do...while循环中是怎么样的：

  1. #include <stdio.h>
  2. int main()
  3. {
  4. 	int i = 1;
  5.     do
  6.     {
  7.         if(5 == i)
  8.             break;
  9.   	  printf("%d\n", i);
  10.       i++;
  11.     }while(i<=10);
  12. 	return 0;
  13. }
  14. //2
  15. int main()
  16. {
  17.     int i = 1;
  18. 	do
  19. 	{
  20.         if(5 == i)
  21.         	continue;
  22. 		printf("%d\n", i);
  23.         i++;
  24. 	}while(i<=10);
  25.     return 0;
  26. }

代码1：

image-20211214143900637

正常跳出循环。

代码2：

image-20211214144006453

死循环了。跟while循环有点类似。

break：跳出break所在的循环体，终止循环。

continue：跳过本次循环continue后面的语句，直接进入下一次循环。

练习题

  1. 计算 n的阶乘。
  2. 计算 1!+2!+3!+……+10!
  3. 在一个有序数组中查找具体的某个数字n。 编写int binsearch(int x, int arr[], int n); 功能：在arr[0]
    <=arr[1]<=arr[2]<= ….<=arr[n-1]的数组中查找x.
  4. 编写代码，演示多个字符从两端移动，向中间汇聚。
  5. 编写代码实现，模拟用户登录情景，并且只能登录三次。（只允许输入三次密码，如果密码正确则提示登录成，如果三次均输入错误，则退出程序 。

计算n的阶乘

阶乘怎么算？阶乘就是 n * n-1 * n-2 * n-3*...*1，那不就是1乘到n嘛，代码如下:

  1. #include <stdio.h>
  2. int main()
  3. {
  4. 	int i = 0;
  5. 	int n = 0;
  6. 	scanf("%d", &n);
  7. 	int  t = 1;
  8. 	for (i = 1; i <= n; i++)
  9. 	{
  10. 		t *= i;
  11. 	}
  12. 	printf("%d ", t);
  13. 	return 0;
  14. }

运行结果：

image-20211214145734531

思路：

阶乘就是1 * 2 * ....* n。那么我们用循环，弄出1~n的数字，然后再定义一个变量t=1，然后用t去成 1 ~ n的每一个数字，从而得到最后的结果。

计算1！+....+10!

计算1！+~10！，我们之间有计算了n的阶乘，那我们在计算n的阶乘之上再嵌套一层循环是不是就可以解决了？

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     int i = 0;
  5.     int t = 1;
  6.     int sum = 0;
  7.     for(i=1;i<=10;i++)
  8.     {
  9.         int j = 0;
  10.         for(j=1;j<=i;j++)
  11.         {
  12.             t *= j;
  13.         }
  14.         sum+=t;
  15.     }
  16.     printf("%d",sum);
  17.     return 0;
  18. }

image-20211214150931722

思路：

要求1 ~ 10的阶乘和，那么算出每个数的阶乘然后再相加在一起就可以了，首先一层循环控制1 ~ 10的数字，这下数字出来了，然后再定义一个循环，循环的初始化为1，第二个循环用来计算阶乘，定义一个变量t，赋值为1，这样每次相乘都是1去乘j的值，不会出现像计算完2的阶乘后，用2的阶乘的值再去计算3的阶乘，这样会出错的，所以在循环内部定义变量t，这样阶乘后在相加在一起，就可以得到1的阶乘加到10的阶乘了。

这种求法效率比较低，我们可以优化一下它

4! = 4 * 3 * 2 * 1; = 4*3！

3!= 3 * 2 * 1;=3*2！

2!= 2 * 1;=2*1！

通过观察我们发现n！会等于n * n-1！。那我们可以用一个循环就能搞定：

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

image-20211214152634967

很明显这种方法效率高。

<span id = “3">查数

在有序数列中查找一个数字，这题挺简单，我们暴力求解就好了:

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     int arr[]={1,2,3,4,5,6,7,8,9,10};
  5.     int x = 6;
  6.     int sz = sizeof(arr)/sizeof(arr[0]);
  7.     int i = 0;
  8.     for(i=0;i<sz;i++)
  9.     {
  10.         if(x==arr[i])
  11.         {
  12.             printf("找到了，下标是%d",i);
  13.             break;
  14.         }
  15.     }
  16.     if(sz==i)
  17.     {
  18.         printf("找不到\n");
  19.     }
  20.     return 0;
  21. }

image-20211214153352665

思路：

我们在一组数字中找一个数首先我们得知道这组数字有多少个，然后再一个一个的去比对，匹配成功就说明找到了，并且退出循环，如果一组数字全部比对完了都没有找到那就是找不到了。

其实还有个更优化的算法，既然是有序的一组数字，那么我先拿这个需要被查找的数字跟最中间的那个数字去做比对，这样就可以省掉一大半的数据去比对了，如果要查找的数字比中间那个数字要大，那左边的一半数字可以扔掉不要了，继续在后面的数字中寻找，然后再用这个方法去比对，最终只剩一个数字再比对，如果没有那就找不到了。这种方法被称为 二分查找法，写成代码又是怎么样的呢？

  1. #include <stdio.h>
  2. int main()
  3. {
  4. 	int arr[]={1,2,3,4,5,6,7,8,9,10};
  5.     int x = 6;
  6.     int sz = sizeof(arr)/sizeof(arr[0]);
  7.     int left = 0;
  8.     int right = sz - 1;
  9.     while(left<=right)//只有坐下标小于或者是等于右下标时候循环才能进行，不然找不了
  10.     {
  11.         int mid = (left+right)/2;
  12.         if(x > arr[mid])
  13.         {
  14.             left = mid+1;
  15.         }
  16.         else if(x < arr[mid])
  17.         {
  18.             right = mid -1;
  19.         }
  20.         else
  21.         {
  22.             printf("找到了，下标为%d",mid);
  23.             break;
  24.         }
  25.     }
  26.     if(left > right)
  27.     {
  28.         printf("找不到\n");
  29.     }
  30. 	return 0;
  31. }

我们看看实际效果：

image-20211214155926033

是不是就找到了呢？这种方式是不是效率更高了。其实大家也可以拿一张纸，在上面写上一组有序的数字，然后把纸折半去找，这样大家会有更深刻的理解。

<span id = “4">多个字符从两端向中间汇聚

首先我们要明白题目的含义，知道是什么意思。多个字符从两端向中间汇聚大概就是以下情况：

image-20211214162245613

这样的话要怎么做呢？我们可以定义两组数组，一组存#########另一组存放welcome to China!!!!，因为我们使用的是字符串，所以需要使用字符串函数求出字符串的长度。然后使用循环，一次把两端的字符放进##数组里去，然后打印，然后两端的下标一加一减，慢慢向中间靠近，就可以打印出这种效果了：

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     char arr1[]="####################";
  5.     char arr2[]="welcome to China!!!!";
  6.     int left = 0;
  7.     int right = strlen(arr2)-1;//strlen是求字符串长度 需要引头文件string.h
  8.     while(left<=right)
  9.     {
  10.         arr1[left]=arr2[left];
  11.         arr1[right]=arr2[right];
  12.         printf("%s",arr1);
  13.         Sleep(1000);//打印完后停留一会，让我们能更清楚的看是怎样变换出来的。需要引头文件Windows.h
  14.         system("cls");//清空屏幕
  15.         left++;
  16.         right--;
  17.     }
  18.     printf("%s",arr1);
  19.     //for循环版
  20.     for(left=0,right=strlen(arr2)-1;left<=right;left++,right--)
  21.     {
  22.         arr1[left]=arr2[left];
  23.         arr1[right]=arr2[right];
  24.         printf("%s",arr1);
  25.         Sleep(1000);//打印完后停留一会，让我们能更清楚的看是怎样变换出来的。需要引头文件Windows.h
  26.         system("cls");//清空屏幕
  27.     }
  28.     return 0;
  29. }

image-20211214163855545

我把所有的都打印出来更直观点。

模拟登录

只允许输入三次密码，如果密码正确则提示登录成功，如果三次均输入错误，则退出程序。

思路：

创建两个字符数组，用循环加判断结构

易错点：字符串相比较不能直接用==，而是要用字符串比较函数strcmp。strcmp(str1,str2)，返回值为0就相等。

  1. #include <stdio.h>
  2. int main()
  3. {
  4.    	char password[]="admin";
  5.     char str[10];
  6.     int i = 0;
  7.     for(i=0;i<3;i++)
  8.     {
  9.         printf("请输入密码:");
  10.         scsanf("%s",str);
  11.         if((strcmp(str,password))==0)
  12.         {
  13.             printf("密码正确，登录成功\n");
  14.             break;
  15.         }
  16.     	else
  17.         {
  18.             printf("密码错误，请重新输入，只有3次机会哦\n");
  19.         }
  20.     }
  21.     if(3==i)
  22.     {
  23.         printf("机会用完，退出程序\n");
  24.         exit(0);//exit是退出程序语句
  25.     }
  26.     return 0;
  27. }

image-20211214165016205

提一下字符串比较函数是怎么比较的：

char str1[]=“abcde”;

char str2[]=“abcdf”

在使用strcmp在比较str1和str2的时候，从左到右依次比较每个字符，比较的是字符的ASCII码值，前4个都是相同的都相等，但是‘e’ 和‘f’就不一样，e的ASCII码值是101，f的ASCII码值是102，所以str1<str2。strcmp返回的就是小于0的值。

猜数字游戏

学了这么多知识了，我们来玩个游戏吧，猜数字。我们输入一个数字，程序会提醒我们输入的数字是大了还是小了，直到我们猜中这个数字。

游戏逻辑：

  1. 电脑自动生成1~200之间的数字。
  2. 猜数字
  • 猜对了，游戏结束。
  • 猜错了，继续猜直到猜对为止。

实现程序思路：

  1. 程序一开始首先打印一个简单的菜单，让用户好选择。
  2. 因为程序无论如何都会执行一次，所以用do....while循环，因为有菜单所以要有选择，用Switch来判断进入哪个环节
  3. 游戏开始后，要生成1~200之间的随机数
  4. 接着才游戏，然后判断猜的数字与随机生成的数字是否相等，可以用个死循环，猜中了就提示游戏结束，退出至菜单页面。

难点在生成1~200之间的随机数上。

产生随机数

生成随机数的函数是rand函数，头文件<stdlib.h>，rand函数返回值是整型。rand函数返回的是0~32767的数字，但是在调用rand函数之前需要使用srand函数设置随机数的生成器，就是在rand函数之前需要使用srand函数，srand函数设置一个随机的起点，需要的参数是个unsigned int无符号整型数字，而srand函数参数如果是一个定值的话，那随机数都是一样的，所以srand函数中要给个变得值，我们可以传一个可变化的量 ---时间 ，时间传进去的实际上是时间戳，怎么获取时间戳呢？用time函数，给time函数传个NULL空指针，time函数返回的是也是整型，而srand需要的是一个unsigned int所以强制类型转换成unsigned int类型。time函数需要头文件<time.h>

srand = ((unsigned int)time(NULL));,我们整个工程中只需要设置一次随机数就可以了。因为需要的是1~200的随机数，所以我们让rand生成的随机数%200，因为%200的余数是0 ~ 199，我们加上1，就得到了1~200的随机数了。

参考代码:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. void menu()
  5. {
  6. 	printf("******************************************\n");
  7. 	printf("************    1. play    ***************\n");
  8. 	printf("************    0. exit    ***************\n");
  9. 	printf("******************************************\n");
  10. }
  11. void game()
  12. {
  13.     int ret = rand()%200+1;
  14.     int k = 0;
  15.     while(1)
  16.     {
  17.         printf("请输入猜的数字:");
  18.         scanf("%d",&k);
  19.         if(k<ret)
  20.         {
  21.             printf("数字小了\n");
  22.         }
  23.         else if(k > ret)
  24.         {
  25.             printf("数字大了\n");
  26.         }
  27.         else
  28.         {
  29.             printf("恭喜你猜中了\n");
  30.             break;
  31.         }
  32.     }
  33. }
  34. int main()
  35. {
  36.     int input = 0;
  37.     srand((unsigned int) time(NULL));
  38.     do
  39.     {
  40.         menu();
  41.         printf("请输入选择:");
  42.         scanf("%d",&input);
  43.         switch(input)
  44.         {
  45.             case 1:
  46.                 game();
  47.                 break;
  48.             case 0:
  49.                 printf("退出游戏\n");
  50.                 break;
  51.             default:
  52.                 printf("输入错误\n");
  53.         }
  54.     }while(input);
  55.     return 0;
  56. }

代码效果:

image-20211214184702781

goto语句

C语言中提供了可以随意滥用的 goto语句和标记跳转的标号。
从理论上 goto语句是没有必要的，实践中没有goto语句也可以很容易的写出代码。

但是某些场合下goto语句还是用得着的,最常见的用法就是终止程序在某些深度嵌套的结构的处理过程，例如一次跳出两层或多层循环。

这种情况使用break是达不到目的的。它只能从最内层循环退出到上一层的循环。写个程序举个例子：

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

执行顺序是：首先进入主函数，然后两端输出函数，flag不用它，走到goto 语句时，它会跳转到flag的位置开始执行，然后接着执行到goto语句，就造成了死循环。

再比如写个关机程序：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. int main()
  5. {
  6.     //关机命令 60秒后自动关机
  7.     system("shutdown -s -t 60");//system()执行系统命令函数  引用头文件<stdlib.h>
  8.      char arr[20]={0};
  9. again:
  10.     printf("请注意，你的电脑将1分钟内关机，如果输入：我是小猪猪，就关机");
  11.     scanf("%s",arr);
  12.     if((strcmp(arr,"我是小猪猪"))==0)
  13.     {
  14.         system("shutdown -a");
  15.     }
  16.     else
  17.     {
  18.         goto again;
  19.     }
  20.     return 0;
  21. }

image-20211214190709075

image-20211214190735013

其实我们用循环也可以实现这个功能的：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. int main()
  5. {
  6.     //关机命令 60秒后自动关机
  7.     system("shutdown -s -t 60");//system()执行系统命令函数  引用头文件<stdlib.h>
  8.      char arr[20]={0};
  9. 	while(1)
  10.     {
  11.     	printf("请注意，你的电脑将1分钟内关机，如果输入：我是小猪猪，就关机");
  12.    	 	scanf("%s",arr);
  13.         if((strcmp(arr,"我是小猪猪"))==0)
  14.         {
  15.             system("shutdown -a");
  16.             break;
  17.         }
  18.     }
  20.     return 0;
  21. }

实际上goto语句使用的场景是：

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

其实在我们自己写程序的时候很少会用到goto语句的，大家知道这个语句就可以了，要是真的要使用的话，查一下资料也会的。

数字炸弹游戏

我自己写了一个数字炸弹游戏不知大家有木有玩过呀？其实就是猜数字和关机程序的结合，学完之后自己也突发奇想之前有玩过这种游戏所以尝试一下自己写这个游戏，参考代码如下：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. void menu()
  5. {
  6. 	printf("******************************************\n");
  7. 	printf("***********欢迎来到数字炸弹游戏!!*********\n");
  8. 	printf("************    1. play    ***************\n");
  9. 	printf("************    0. exit    ***************\n");
  10. 	printf("******************************************\n");
  11. }
  12. void game()
  13. {
  14.     int ret = rand() % 200 + 1;
  15.     int guess = 0;
  16.     char str[20] = { 0 };
  17.     int i = 0;
  18.     for (i = 0; i < 5; i++)
  19.     {
  20.         printf("请输入猜的数字：\n");
  21.         scanf("%d", &guess);
  22.         if (guess > ret)
  23.         {
  24.             printf("数字大了\n");
  25.         }
  26.         else if (guess < ret)
  27.         {
  28.             printf("数字小了\n");
  29.         }
  30.         else
  31.         {
  32.             printf("恭喜你猜中了!\n");
  33.         }
  34.     }
  35.     if (5 == i)
  36.     {
  37.         printf("你输了!作为惩罚你的电脑将在1分钟后关机!!!\n");
  38.         system("shutdown -s -t 60");
  39.     }
  40.     printf("如果你想继续玩耍,就输入“我是小猪猪”。只有3次机会哦!\n");
  41.     for (i = 0; i < 3; i++)
  42.     {
  43.         printf("请输入:\n");
  44.         scanf("%s", str);
  45.         if ((strcmp(str, "我是小猪猪")) == 0)
  46.         {
  47.             system("shutdown -a");
  48.             break;
  49.         }
  50.     }
  51.     if (3 == i)
  52.     {
  53.         printf("机会用完了哦，1分钟后关机\n");
  54.         system("shutdown -s -t 60");
  55.         exit(0);
  56.     }
  58. }
  59. int main()
  60. {
  61.     int input = 0;
  62.     srand((unsigned int)time(NULL));
  63.     do
  64.     {
  65.         menu();
  66.         printf("请输入选择:");
  67.         scanf("%d", &input);
  68.         switch (input)
  69.         {
  70.         case 1:
  71.             game();
  72.             break;
  73.         case 0:
  74.             printf("退出游戏\n");
  75.             break;
  76.         default:
  77.             printf("输入错误\n");
  78.         }
  79.     } while (input);
  80.     return 0;
  81. }

有哪些知识点没讲好的大家见谅哈，菜鸟报道哈哈哈哈。大家一起加油呀！！！谢谢大家的收看！！！阿里嘎多。

荆轲刺秦王img

原文链接：http://www.cnblogs.com/L-wk/p/15700889.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C 语言热门文章

  • 图形学入门(1)——直线生成算法（DDA和Bresenham）
  • 用C语言制作一个最简单的飞机游戏！
  • MODBUS 超时时间计算
  • zabbix wait for 15s seconds 出现原因及调优建议
  • C/C++知识分享：assert()函数
  • 图形学入门(2)——圆弧生成算法（中点画圆法）
  • C 共享内存封装
  • C语言中break与continue的用法和区别详解
  • GStreamer基础教程09 - Appsrc及Appsink
  • 三元组矩阵行列式的计算（用递归）

    • C 语言推荐文章

  • C语言指针易混淆知识点总结
  • 进程间通信
  • 数组降维、函数栈帧、地址空间、可变参数原理剖析
  • 【Learning eBPF-3】一个 eBPF 程序的深入剖析
  • [apue] 进程控制那些事儿
  • 解密C语言选择结构：掌握条件语句与分支逻辑的利器
  • 精通C语言：打造高效便捷的通讯录管理系统
  • c语言实现内存池
  • [数据结构] 数组与特殊矩阵
  • 探索C语言结构体：编程中的利器与艺术

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号