循环结构程序设计
while 循环语句
C语言包含3大基本结构：顺序结构、选择结构、循环结构
while语句的一般形式：
while (表达式) 语句
只有当循环条件表达式为真,就执行循环体语句。为假的时不执行循环体语句。循环体语句可以是一个简单的语句，也可以是复合语句
例如：实现将公元0年 ~ 10000年的所有闰年都打印出来
示例：
#include "stdio.h"
void main()
{
int year = 0;
while (year <= 10000)
{
if (((year % 4 == 0) && (year % 100 != 0)) || year % 400 == 0)
{
printf("%d是闰年\n", year);
}
++year;
}
}
结果：
[Running] cd "d:\vscode(C语言)\" && gcc 循环结构程序设计.c -o 循环结构程序设计 && "d:\vscode(C语言)\"循环结构程序设计
0是闰年
4是闰年
...
[Done] exited with code=399 in 0.201 seconds
do...while 循环语句
C语言除了while循环，还有一种变体do…while语句来实现循环
do…while语句的一般形式：
do
语句
while(表达式)
注意：do…while语句的特点是：先无条件的执行循环体语句，然后判断表达式是否成立。如果成立，返回到语句继续执行。如果不成立，则结束do…while，继续向下执行剩余代码
示例：
#include "stdio.h"
void main()
{
int year = 0;
do
{
if (((year % 4 == 0) && (year % 100 != 0)) || year % 400 == 0)
{
printf("%d是闰年\n", year);
}
year++;
} while (year <= 10000);
}
结果：
[Running] cd "d:\vscode(C语言)\" && gcc 循环结构程序设计.c -o 循环结构程序设计 && "d:\vscode(C语言)\"循环结构程序设计
0是闰年
4是闰年
...
[Done] exited with code=15 in 0.197 seconds
示例：求1+2+3+...+100的和
#include "stdio.h"
void main()
{
int i = 0, sum = 0;
do
{
sum += i; //相当于sum = sum + i;
// printf("每次循环的累加和为：%d\n", sum);
++i;
} while (i <= 100);
printf("1+2+3+...+100的和为：%d\n", sum);
}
结果：
[Running] cd "d:\vscode(C语言)\" && gcc 循环结构程序设计.c -o 循环结构程序设计 && "d:\vscode(C语言)\"循环结构程序设计
1+2+3+...+100的和为：5050
[Done] exited with code=30 in 0.181 seconds
for 循环语句
for语句的一般形式
C语言除了while循环及do…while循环，还有一种for语句来实现循环。for语句更为灵活，且完全可以替代while语句
for 语句的一般形式：
for( 表达式1; 表达式2; 表达式3 )
语句
-
表达式1：一般用于设置初始条件，只执行一次。可以为0个、1个或多个变量初始化
-
表达式2：是循环条件表达式，用来判定是否继续循环，在每次执行循环体前判断表达式2，为真继续执行循环体语句，为假则结束for循环语句
-
表达式3：每执行完一次循环体后执行一次表达式3，一般用于循环体变量增值
示例：
#include "stdio.h"
void main()
{
int year;
for (year = 0; year <= 10000; year++)
{
if (((year % 4 == 0) && (year % 100 != 0)) || year % 400 == 0)
{
printf("%d是闰年\n", year);
}
}
}
结果：
[Running] cd "d:\vscode(C语言)\" && gcc 循环结构程序设计.c -o 循环结构程序设计 && "d:\vscode(C语言)\"循环结构程序设计
0是闰年
4是闰年
...
[Done] exited with code=200 in 0.178 seconds
for 语句的说明
for语句的形式：
for( 表达式1; 表达式2; 表达式3 )
语句
改写成while形式如下：
表达式1;
while(表达式2)
{
语句
表达式3
}
两种形式无条件等价
-
表达式1可以省略，即不设置初值，但后面的分号不能省略，代表空语句
-
表达式2省略的情况下，将无限循环下去
-
表达式1和表达式3可以是一个简单的表达式，也可以是逗号表达式
-
表达式2一般是关系表达式或逻辑表达式，但也可以是数值表达式或字符表达式，只要值不为0，就执行循环体
-
c99允许在for语句的表达式1中定义变量并赋初始值
注：不要将无关的不需要循环的内容放在循环体中
循环嵌套
一个循环体内又包含了一个完整的循环结构，称为循环的嵌套。内嵌的循环中还可以嵌套循环，这就是多层嵌套
例如：
while()
{
...
while()
{ ...
} //第四、五、六行为内层循环
}
while()
{ ...
do
{ ... }
while();
...
}
do
{ ...
do
{ ... }
while();
}while( .... );
for(... ; ... ; ...)
{
...
for(... ; ... ; ...)
{ ... }
}
for(... ; ... ; ...)
{
while()
{ ... }
...
}
for(... ; ... ; ...)
{
...
do
{ ... }
while();
}
嵌套循环，将内层循环执行完之后执行一次外层循环
几种循环的比较：
- 3种循环都可以用来处理统一问题，一般情况下它们是可以互相替换
- for语句中包含了3个表达式，而while语句只有一个表达式
- for语句可以对值进行初始化，for语句更加强大
示例：九九乘法表
#include "stdio.h"
void main()
{
int x, y;
for (x = 1; x <= 9; x++)
{
for (y = 1; y <= 9; y++)
{
printf("%d*%d=%d\t", y, x, x * y);
}
printf("\n");
}
}
结果：
[Running] cd "d:\vscode(C语言)\" && gcc 循环结构程序设计.c -o 循环结构程序设计 && "d:\vscode(C语言)\"循环结构程序设计
1*1=1 2*1=2 3*1=3 4*1=4 5*1=5 6*1=6 7*1=7 8*1=8 9*1=9
1*2=2 2*2=4 3*2=6 4*2=8 5*2=10 6*2=12 7*2=14 8*2=16 9*2=18
1*3=3 2*3=6 3*3=9 4*3=12 5*3=15 6*3=18 7*3=21 8*3=24 9*3=27
1*4=4 2*4=8 3*4=12 4*4=16 5*4=20 6*4=24 7*4=28 8*4=32 9*4=36
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 6*5=30 7*5=35 8*5=40 9*5=45
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 7*6=42 8*6=48 9*6=54
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 8*7=56 9*7=63
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 9*8=72
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
[Done] exited with code=10 in 0.187 seconds
示例：实现时钟
#include "stdio.h"
#include "windows.h"
void main()
{
int H, M, S;
for (H = 0; H <= 24; H++)
{
for (M = 0; M < 60; M++)
{
for (S = 0; S < 60; S++)
{
Sleep(100); //让程序暂停100毫秒
printf("\r%dH~%dM~%dS", H, M, S); // '/r' 的作用是让光标保持在最前面
}
}
}
}
结果：
0H~0M~3S //时间会随着运行慢慢变化
break 和 continue 语句
break 语句
break语句可以使流程跳出switch结构，继续执行switch语句下面一个语句。break语句也可以用来跳出当前循环体
例如：计算1+2+3+… 一直累加，当值大于x（x由用户输入）时，打印一共累加了几个数，并结束程序？
示例：
#include "stdio.h"
void main()
{
int i, t = 0, x;
// scanf("%d", &x);
for (i = 0;; i++)
{
t += i;
if (t > x)
{
printf("一共累加了%d个数\n", i);
break;
}
}
}
结果：
10
一共累加了5个数
Press any key to continue
continue 语句
continue语句：结束本次循环，跳过循环体中下面尚未执行的语句
示例：
#include "stdio.h"
void main()
{
int x, y;
for (x = 1; x <= 9; x++)
{
for (y = 1; y <= 9; y++)
{
if (x <= y)
printf("%d*%d=%d\t", x, y, x * y);
else
continue;
}
printf("\n");
}
}
结果：
[Running] cd "d:\vscode(C语言)\" && gcc 循环结构程序设计.c -o 循环结构程序设计 && "d:\vscode(C语言)\"循环结构程序设计
1*1=1 1*2=2 1*3=3 1*4=4 1*5=5 1*6=6 1*7=7 1*8=8 1*9=9
2*2=4 2*3=6 2*4=8 2*5=10 2*6=12 2*7=14 2*8=16 2*9=18
3*3=9 3*4=12 3*5=15 3*6=18 3*7=21 3*8=24 3*9=27
4*4=16 4*5=20 4*6=24 4*7=28 4*8=32 4*9=36
5*5=25 5*6=30 5*7=35 5*8=40 5*9=45
6*6=36 6*7=42 6*8=48 6*9=54
7*7=49 7*8=56 7*9=63
8*8=64 8*9=72
9*9=81
[Done] exited with code=10 in 0.208 seconds
扩展
1、求斐波那契数列的前20个数；特点：第一、二个数为1，从第三个数开始，该数是前面两个数之和（例如：1、1、2、3、5、8、13、...）
示例：
#include "stdio.h"
void main()
{
int a = 1, b = 1, c, i;
printf("%d\t%d\t", a, b);
for (i = 1; i <= 18; i++)
{
c = a + b;
printf("%d\t", c);
a = b;
b = c;
}
printf("\n");
}
结果：
[Running] cd "d:\vscode(C语言)\" && gcc 循环结构程序设计.c -o 循环结构程序设计 && "d:\vscode(C语言)\"循环结构程序设计
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
[Done] exited with code=10 in 0.188 seconds
2、输入一个大于3的整数n，判断它是否为素数，不能被小于自己的整数除（除1以外）
例如：2、3、5、7、11、13、17、19、...
示例：
#include "stdio.h"
void main()
{
int n, i;
printf("请输入一个整数：\n");
scanf("%d", &n);
for (i = 2; i < n; i++)
if (n % i == 0)
break;
if (i < n)
printf("%d不是素数\n", n);
else
printf("%d是素数\n", n);
}
结果：
请输入一个整数：111
111不是素数
Press any key to continue
3、输出100以内的素数与非素数
示例：
#include "stdio.h"
void main()
{
int n = 2, i;
while (n <= 100)
{
for (i = 2; i < n; i++)
if (n % i == 0)
break;
if (i < n)
printf("%d为非素数\n", n);
else
printf("%d为素数\n", n);
++n;
}
}
结果：
[Running] cd "d:\vscode(C语言)\" && gcc 循环结构程序设计.c -o 循环结构程序设计 && "d:\vscode(C语言)\"循环结构程序设计
2为素数 3为素数 4为非素数 5为素数 6为非素数 7为素数 8为非素数 9为非素数 10为非素数 11为素数 12为非素数 13为素数 14为非素数 15为非素数
...
[Done] exited with code=16 in 0.188 seconds
4、其它
示例：
#include <stdio.h>
#include <math.h>
float f(float x, float y, float z)
{
float a;
a = x * x + 9.0f / 4.0f * y * y + z * z - 1;
return a * a * a - x * x * z * z * z - 9.0f / 80.0f * y * y * z * z * z;
}
float h(float x, float z)
{
float y;
for (y = 1.0f; y >= 0.0f; y -= 0.001f)
if (f(x, y, z) <= 0.0f)
return y;
return 0.0f;
}
void main()
{
float z, x, v, y0, ny, nx, nz, nd, d;
for (z = 1.5f; z > -1.5f; z -= 0.05f)
{
for (x = -1.5f; x < 1.5f; x += 0.025f)
{
v = f(x, 0.0f, z);
if (v <= 0.0f)
{
y0 = h(x, z);
ny = 0.01f;
nx = h(x + ny, z) - y0;
nz = h(x, z + ny) - y0;
nd = 1.0f / sqrt(nx * nx + ny * ny + nz * nz);
d = (nx + ny - nz) * nd * 0.5f + 0.5f;
putchar(".:-=+*#%@"[(int)(d * 5.0f)]);
}
else
putchar(' ');
}
putchar('\n');
}
getchar();
}