ios开发环境 分支语句 、 循环结构（for） 、 循环结构

1 完成命令解析程序

1.1 问题

有命令解析程序，该程序提供三个功能选项供用户选择，用户选择某功能后，程序在界面上输出用户所选择的功能名称。程序的交互效果如图-1所示：

图-1

由上图可以看出，程序提供的功能有：显示全部记录、查询登录记录和退出。如果用户在控制台输入1，则表示用户选择的功能为“显示全部记录”，此时，需要在界面上输出该功能的名称。

如果用户在控制台输入2，则表示用户选择的功能为“查询登录记录”，此时，也需要在界面上输入该功能的名称，交互效果如图-2所示:

图-2

如果用户在控制台输入0，则表示用户选择的功能为“退出”。此时，在界面上输出“欢迎使用”，表示程序结束。交互效果如图-3所示:

图-3

如果用户输入除0、1、2以外的其它数字，则表示选择错误，此时，在界面上输出“输入错误“。程序交互情况如图-4所示:

图-4

1.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义变量

变量command，用于保存用户从控制台输入的命令。

代码如下：

1. #include <stdio.h>
2. int main()
3. {
4. int command = 0;
5. return 0;
6. }

步骤二：从控制台输入命令

首先，使用printf函数输出一行提示。

然后，使用scanf函数输入一个整数到变量command。

代码如下：

1. #include <stdio.h>
2. int main()
3. {
4. int command = 0;
5. printf("请选择功能：1.显示全部记录 2.查询登录记录 0.退出\n");
6. scanf("%d", &command);
7. return 0;
8. }

步骤三：使用switch解析命令

将switch结构配合break语句一起使用，判断用户的选择操作，并输出解析结果。

代码如下：

1. #include <stdio.h>
2. int main()
3. {
4. int command = 0;
5. printf("请选择功能：1.显示全部记录 2.查询登录记录 0.退出\n");
6. scanf("%d", &command);
7. switch (command) {
8. case 1:
9. printf("显示全部记录\n");
10. break;
11. case 2:
12. printf("查询登录记录\n");
13. break;
14. case 0:
15. printf("欢迎使用\n");
16. break;
17. default:
18. printf("输入错误\n");
19. break;
20. }
21. return 0;
22. }

1.3 完整代码

本案例的完整代码如下所示：

1. #include <stdio.h>
2. int main()
3. {
4. int command = 0;
5. printf("请选择功能：1.显示全部记录 2.查询登录记录 0.退出\n");
6. scanf("%d", &command);
7. switch (command) {
8. case 1:
9. printf("显示全部记录\n");
10. break;
11. case 2:
12. printf("查询登录记录\n");
13. break;
14. case 0:
15. printf("欢迎使用\n");
16. break;
17. default:
18. printf("输入错误\n");
19. break;
20. }
21. return 0;
22. }

2 求圆周率

2.1 问题

圆周率，一般以π来表示，是一个在数学及物理学普遍存在的数学常数。它定义为圆形之周长与直径之比，也等于圆形面积与半径的平方之比，是精确计算圆周长、圆面积、球体积等几何形状的关键值。

圆周率是一个无限不循环小数。在日常生活中，通常都用3.14来代表圆周率去进行近似计算。如果需要精确计算圆周率的值，则可以使用如下公式：

π/4=1-1/3+1/5-1/7+1/9-1/11+……

本案例要求使用上述公式计算圆周率π的值。为保证一定的精确度，要求计算至10亿次后的结果。程序运行效果如图-5：

图-5

2.2 方案

计算π值的公式为：

π=4*(1-1/3+1/5-1/7+1/9-1/11+1/13-1/15……)

有上述公式可以看出，如果需要计算π的值，必须先计算表达式1-1/3+1/5-1/7+1/9-1/11+1/13-1/15……的值。分析此表达式，不难发现，此表达式中的每个计算因子的构成类似，可以总结出如下规律：flag * 1.0 / n。其中，flag表示每个计算因子前面的正号或负号。比如，1可以表示为1*1.0/1;-1/3可以表示为-1*1.0/3;1/5可以表示为1*1.0/5。

对于表达式flag * 1.0 / n，flag和n是变化的数值，因此，可以分别声明变量来表示它，并为其赋初始值，代码如下：

1. int flag = -1;
2. int n = 1;

每次计算时，flag和n的值都会发生变化，其变化规律如表-1：

为保证一定的精确度，要求计算至10亿次后的结果，因此，需要使用for循环构建10亿次的计算，而每次循环中，需要修改flag值，然后累加表达式flag*1.0/n的结果，并将n的数值加上2，用于下一次计算。程序流程图如图-6：

图-6

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义变量

定义变量pi，用于存储计算出的π值。

定义变量flag，用于存储计算过程中的正号和负号。

代码如下：

1. #include <stdio.h>
2. int main()
3. {
4. double pi = 0;
5. int flag = -1;
6. return 0;
7. }

步骤二：构建循环

结合变量n，使用for循环构建10亿次计算。每次循环中，改变flag的值，并累加计算结果。

代码如下：

1. #include <stdio.h>
2. int main()
3. {
4. double pi = 0;
5. int flag = -1;
6. for (int n = 1; n < 1000000000; n +=2)
7. {
8. flag *= -1;
9. pi += flag * 1.0 / n;
10. }
11. return 0;
12. }

步骤三：输出结果

代码如下：

1. #include <stdio.h>
2. int main()
3. {
4. double pi = 0;
5. int flag = -1;
6. for (int n = 1; n < 1000000000; n +=2)
7. {
8. flag *= -1;
9. pi += flag * 1.0 / n;
10. }
11. printf("pi = %.15lf\n", pi * 4);
12. return 0;
13. }

2.4 完整代码

本案例的完整代码如下所示：

1. #include <stdio.h>
2. int main()
3. {
4. double pi = 0;
5. int flag = -1;
6. for (int n = 1; n < 1000000000; n +=2)
7. {
8. flag *= -1;
9. pi += flag * 1.0 / n;
10. }
11. printf("pi = %.15lf\n", pi * 4);
12. return 0;
13. }

3 猜数字游戏

3.1 问题

有猜数字游戏，其游戏规则为：程序内置一个1~100之间的数字作为猜测的结果，由用户猜测此数字。用户每猜测一次，由系统提示猜测结果：大了、小了或者猜对了；直到用户猜对结果，则提示游戏结束。

本案例要求使用交互的方式实现此游戏，交互过程为：

1) 游戏刚开始，提示用户在控制台输入所猜测的数字（为1~100之间的整数），交互过程如图-7所示：

图-7

2) 用户录入所猜测的数字后，程序进行判断：如果用户所猜测的数字大于结果，则提示太大了；如果用户所猜测的数字小于结果，则提示太小了。每次提示猜测结果后，提醒用户继续猜测。交互过程如图-8所示：

图-8

3) 直到用户猜测正确，则由系统提示“恭喜，你猜对了！”，游戏结束。交互过程如图-9：

图-9

3.2 方案

首先，此案例中，需要产生一个1~100之间的随机整数，该数值就是用户要猜测的结果；然后，提示用户进行第一次猜测，并得到用户从界面所输入的数字。

因为猜测的次数不确定，则使用do-while循环来构建猜测的过程：判断用户所猜测的数字是否与结果相同，只有猜测不正确，则继续循环。每次循环中，根据比较结果输出提示信息（“太大了”或者“太小了”），并提示用户进行下一次猜测。

如果用户猜测正确，则循环结束，并提示用户“恭喜，你猜对了！”，程序结束。程序流程图如下图-10：

图-10

3.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义变量

定义变量num，用于存储系统生成的随机数，即猜测对象。

定义变量guess，用于存储用户输入的猜测值。

代码如下：

1. #include <stdio.h>
2. #include <time.h>
3. #include <stdlib.h>
4. int main()
5. {
6. int num;
7. int guess;
8. return 0;
9. }

步骤二：产生随机数

srand和rand()配合使用产生伪随机数序列。rand函数在产生随机数前，需要系统提供的生成伪随机数序列的种子，rand根据这个种子的值产生一系列随机数。如果系统提供的种子没有变化，每次调用rand函数生成的伪随机数序列都是一样的。srand(unsigned seed)通过参数seed改变系统提供的种子值，从而可以使得每次调用rand函数生成的伪随机数序列不同，从而实现真正意义上的“随机”。通常可以利用系统时间来改变系统的种子值，即srand(time(0))，可以为rand函数提供不同的种子值，进而产生不同的随机数序列。

使用rand()函数返回一个0到RAND_MAX之间的随机数。RAND_MAX为2147483647。然后，将随机数整除100求余数，则可以生成一个0~99之间的随机数（包含0，也包含99），再加上数值1，则可以得到1~100之间的随机整数（包含1，也包含100）表示要猜测的数字。

注意：rand()函数与srand()函数需要在程序开头包含stdlib.h头函数；time()函数需要在程序开头包含time.h头函数。

代码如下：

1. #include <stdio.h>
2. #include <time.h>
3. #include <stdlib.h>
4. int main()
5. {
6. int num;
7. int guess;
8. srand((unsigned)time(0));//time函数的声明在time.h头函数中
9. num = rand() % 100;//srand函数与rand函数的声明在stdlib.h中
10. return 0;
11. }

步骤三：读取猜测结果

提示用户输入猜测的数字，作为一次猜测。代码如下所示：

1. #include <stdio.h>
2. #include <time.h>
3. #include <stdlib.h>
4. int main()
5. {
6. int num;
7. int guess;
8. srand((unsigned)time(0));
9. num = rand() % 100;
10. printf("请输入你猜测的数字（1~100）：");
11. scanf("%d", &guess);
12. return 0;
13. }

步骤四：判断结果

使用if-else结构判断用户猜测的数字和实际数字的大小，并根据比较结果输出提示信息（“太大了”或“太小了”）。代码如下所示：

1. #include <stdio.h>
2. #include <time.h>
3. #include <stdlib.h>
4. int main()
5. {
6. int num;
7. int guess;
8. srand((unsigned)time(0));
9. num = rand() % 100;
10. printf("请输入你猜测的数字（1~100）：");
11. scanf("%d", &guess);
12. if (guess > num)
13. printf("太大了\n");
14. else if (guess < num)
15. printf("太小了\n");
16. return 0;
17. }

步骤五：构建循环

如果用户猜测的数字和实际数字不相等，则反复要求用户猜测，直到猜对为止。

代码如下所示：

1. #include <stdio.h>
2. #include <time.h>
3. #include <stdlib.h>
4. int main()
5. {
6. int num;
7. int guess;
8. srand((unsigned)time(0));
9. num = rand() % 100;
10. do
11. {
12. printf("请输入你猜测的数字（1~100）：");
13. scanf("%d", &guess);
14. if (guess > num)
15. printf("太大了\n");
16. else if (guess < num)
17. printf("太小了\n");
18. }while(num != guess);
19. return 0;
20. }

步骤六：游戏结束

如果用户猜测的数字和实际数字相等，则代表用户猜测正确，终止循环，并提示用户正确信息“恭喜，你猜对了！”。

代码如下所示：

1. #include <stdio.h>
2. #include <time.h>
3. #include <stdlib.h>
4. int main()
5. {
6. int num;
7. int guess;
8. srand((unsigned)time(0));
9. num = rand() % 100;
10. do
11. {
12. printf("请输入你猜测的数字（1~100）：");
13. scanf("%d", &guess);
14. if (guess > num)
15. printf("太大了\n");
16. else if (guess < num)
17. printf("太小了\n");
18. }while(num != guess);
19. printf("恭喜，你猜对了！\n");
20. return 0;
21. }

3.4 完整代码

本案例的完整代码如下所示：

1. #include <stdio.h>
2. #include <time.h>
3. #include <stdlib.h>
4. int main()
5. {
6. int num;
7. int guess;
8. srand((unsigned)time(0));
9. num = rand() % 100;
10. do
11. {
12. printf("请输入你猜测的数字（1~100）：");
13. scanf("%d", &guess);
14. if (guess > num)
15. printf("太大了\n");
16. else if (guess < num)
17. printf("太小了\n");
18. }while(num != guess);
19. printf("恭喜，你猜对了！\n");
20. return 0;
21. }

4 登录合法判断程序

4.1 问题

创建C语言程序，模拟网站的登录验证过程。需求为：从控制台输入密码，由程序判断密码是否正确，如果密码正确，则登录成功，程序交互过程如图-11：

图-11

如果密码不正确，则反复要求输入密码，程序交互过程如图-12：

图-12

4.2 方案

本案例的实现方案如图-13所示：

图-13

4.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义变量

变量password，用于保存用户从控制台输入的密码。

代码如下：

1. #include <stdio.h>
2. int main()
3. {
4. int password;
5. return 0;
6. }

步骤二：从控制台输入密码

首先，使用printf函数输出一行提示，提示输入一个密码。

然后，使用scanf函数输入一个整数到变量password。

代码如下：

1. #include <stdio.h>
2. int main()
3. {
4. int password;
5. printf("请输入密码:");
6. scanf("%d", &password);
7. return 0;
8. }

步骤三：构建循环

构建循环，循环的终止条件是用户输入的密码不正确，循环体为步骤二的输入密码。代码如下：

1. #include <stdio.h>
2. int main()
3. {
4. int password;
5. do {
6. printf("请输入密码:");
7. scanf("%d", &password);
8. } while (password != 123456);
9. return 0;
10. }

步骤四：输入的密码正确，显示登录成功

代码如下：

1. #include <stdio.h>
2. int main()
3. {
4. int password;
5. do {
6. printf("请输入密码:");
7. scanf("%d", &password);
8. } while (password != 123456);
9. printf("登录成功\n");
10. return 0;
11. }

4.4 完整代码

本案例的完整代码如下所示：

1. #include <stdio.h>
2. int main()
3. {
4. int password;
5. do {
6. printf("请输入密码:");
7. scanf("%d", &password);
8. } while (password != 123456);
9. printf("登录成功\n");
10. return 0;
11. }

5 输入整数，输出所有整数的和

5.1 问题

编写一个求和程序。用户从控制台输入的整数的个数不受限制，直到输入整数0为止。将输入的整数逐个相加后，把结果输出。控制台交互情况如图-14：

图-14

5.2 方案

本案例的实现方案如图-15所示：

图-15

5.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义变量

变量num，用于保存用户从控制台输入的整数。

变量sum，用于保存输入的整数的累加和。

代码如下：

1. #include <stdio.h>
2. int main()
3. {
4. int num;
5. int sum = 0;
6. return 0;
7. }

步骤二：从控制台输入整数

首先，使用scanf函数输入一个整数到变量num。

然后，将输入的整数累加到变量sum中。

代码如下：

1. #include <stdio.h>
2. int main()
3. {
4. int num;
5. int sum = 0;
6. scanf("%d", &num);
7. sum += num;
8. return 0;
9. }

步骤三：构建循环

构建循环，循环的终止条件是用户输入的整数为0，循环体为步骤二的输入整数和将输入的整数求累加和。代码如下：

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

步骤四：输出累加和

代码如下：

1. #include <stdio.h>
2. int main()
3. {
4. int num;
5. int sum = 0;
6. do
7. {
8. scanf("%d", &num);
9. sum += num;
10. }while(num != 0);
11. printf("sum = %d\n", sum);
12. return 0;
13. }

5.4 完整代码

本案例的完整代码如下所示：

1. #include <stdio.h>
2. int main()
3. {
4. int num;
5. int sum = 0;
6. do
7. {
8. scanf("%d", &num);
9. sum += num;
10. }while(num != 0);
11. printf("sum = %d\n", sum);
12. return 0;
13. }

6 打印10以内的整数，跳过5

6.1 问题

在控制台上打印0、1、2、3、4、6、7、8、9，注意5不打印，效果如图-16所示：

图-16

6.2 方案

本案例的实现方案如图-17所示：

图-17

6.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：构建循环

构建循环，循环10次，循环体为输出循环变量i。代码如下：

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

步骤二：循环变量i为5时，循环体不打印循环变量

在循环体中插入代码，代码的功能是判断循环变量是否为5，如果是将继续循环，不再打印循环变量。

代码如下：

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

6.4 完整代码

本案例的完整代码如下所示：

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

7 用for循环嵌套打印各种图形(矩形，三角)

7.1 问题

在控制台上打印矩形图形，效果如图-18所示：

图-18

在控制台上打印三角形，效果如图-19所示：

图-19

7.2 方案

此方案需要使用嵌套循环来实现。

由图-20可知，矩形一共需要输出5行10列星：

图-20

5行需要一个循环5次的循环，代码如下所示：

1. //变量i用于控制行数
2. for (int i=0; i<5; i++) {
3. }

在输出每行中的内容时，还需要一个循环10次的循环，在一行中输出10列，即10个星，代码如下所示：

1. //变量i用于控制行数
2. for (int i=0; i<5; i++) {
3. //变量j用于控制列数
4. for (int j=0; j<10; j++) {
5. }
6. }

由下图可知，三角形一共需要输出5行，第1行先输出4个空格，再输出一颗星，第2行先输出3个空格，再输出3颗星，第3行先输出2个空格，再输出5颗星，第4行先输出1个空格，再输出7颗星，第5行不输出空格，直接输出9颗星，详见图-21：

图-21

打印5行星，需要一个循环5次的循环来完成，代码如下：

1. //变量i用于控制行数
2. for (int i=0; i<5; i++) {
3. }

在输出每行中的内容时，首先需要打印空格，行数每增加1行，空格就少打一个，所以打印空格也需要一个循环来完成。然后打印星，行数每增加1行，星就多打两个，所以打印星还需要一个循环来完成。这样，在输出每行时，实际上需要两个循环分别打印空格和星。代码如下所示：

1. //变量i用于控制行数
2. for (int i = 0; i < 5; i++)
3. {
4. //变量j用于控制每行中需要打印的空格个数，i等于0时，第1行打印4个空格，i等于1时，第2行打印3个空格，……
5. for (int j = 4; j > i; j--)
6. {
7. }
8. //变量j还用于控制每行中需要打印的星个数，i等于0时，第1行打印1个星，i等于1时，第2行打印3个星，i等于2时，第3行打印5个星，……
9. for (int j = 0; j < i * 2 + 1; j++)
10. {
11. }
12. printf("\n");
13. }

7.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：打印矩形

在main方法中，构建两层嵌套的for循环：外层循环用于控制行，内层循环用于控制某行上的星。需要注意的是，每行输出完毕后，需要换行。代码如下所示：

1. #include <stdio.h>
2. int main()
3. {
4. //变量i用于控制行数
5. for (int i=0; i<5; i++) {
6. //变量j用于控制列数
7. for (int j=0; j<10; j++) {
8. printf("*");
9. }
10. //每行输出完毕后，需要换行
11. printf("\n");
12. }
13. printf("---------------------------\n");
14. return 0;
15. }

步骤二：打印三角形

在main方法中，构建两层嵌套的for循环：外层循环用于控制行，内层循环有两个，一个用于控制某行上输出的空格，一个用于控制某行上输出的星。需要注意的是，每行输出完毕后，需要换行。代码如下所示：

1. #include <stdio.h>
2. int main()
3. {
4. printf("---------------------------\n");
5. //变量i用于控制行数
6. for (int i = 0; i < 5; i++)
7. {
8. //变量j用于控制每行中需要打印的空格个数
9. for (int j = 4; j > i; j--)
10. printf(" ");
11. //变量j还用于控制每行中需要打印的星个数
12. for (int j = 0; j < i * 2 + 1; j++)
13. printf("*");
14. printf("\n");
15. }
16. return 0;
17. }

7.4 完整代码

本案例的完整代码如下所示：

1. #include <stdio.h>
2. int main()
3. {
4. //变量i用于控制行数
5. for (int i=0; i<5; i++) {
6. //变量j用于控制列数
7. for (int j=0; j<10; j++) {
8. printf("*");
9. }
10. printf("\n");
11. }
12. printf("---------------------------\n");
13. //变量i用于控制行数
14. for (int i = 0; i < 5; i++)
15. {
16. //变量j用于控制每行中需要打印的空格个数
17. for (int j = 4; j > i; j--)
18. printf(" ");
19. //变量j还用于控制每行中需要打印的星个数
20. for (int j = 0; j < i * 2 + 1; j++)
21. printf("*");
22. printf("\n");
23. }
24. return 0;
25. }