目录
5.4 switch 语句中的 case 和 default 的顺序问题
9.1 while 循环中的 break 和 continue
9.3 do while 循环中的 break 和 continue
C语⾔是结构化的程序设计语⾔，这⾥的结构指的是顺序结构、选择结构、循环结构，C语⾔是能够实现这三种结构的，其实我们如果仔细分析，我们⽇常所⻅的事情都可以拆分为这三种结构或者这三种结构的组合。
我们可以使⽤ if 、 switch 实现分⽀结构，使⽤ for 、 while 、 do while 实现循环结构。
1. if 语句
1.1 if
if 语句的语法形式如下：
if(表达式)
语句表达式成⽴（为真），则语句执⾏，表达式不成⽴（为假），则语句不执⾏。在C语⾔中，0为假，⾮0表⽰真，也就是表达式的结果如果是0，则语句不执⾏，表达式的结果如果是不是0，则语句执⾏。
例子：输⼊⼀个整数，判断是否为奇数
#include <stdio.h>
int main()
{
int num = 0;
scanf("%d", &num);
if(num % 2 == 1)
printf("%d 是奇数\n", num);
return 0;
}1.2 else
如果⼀个数不是奇数，那就是偶数了，如果任意⼀个整数，我们要清楚的判断是奇数还是偶数怎么表⽰呢？
这⾥就需要 if...else... 语句了，语法形式如下：
if(表达式)
语句1
else
语句2例子： 输⼊⼀个整数，判断是否为奇数，如果是奇数打印是奇数，否则打印数偶数。
#include <stdio.h>
int main()
{
int num = 0;
scanf("%d", &num);
if(num % 2 == 1)
printf("%d 是奇数\n", num);
else
printf("%d 是偶数\n", num);
return 0;
}1.3 分支中包含多条语句
默认在 if 和 else 语句中默认都只控制⼀条语句，若是需要多条语句执行怎么办？可以在 if 和
else 后边添加一对大括号{}，一对大括号表示一个代码块。例如：
#include <stdio.h>
int main()
{
int age = 0;
scanf("%d", &age);
if(age >= 18) //if 后使⽤{} 控制多条语句-这个块也叫：程序块，或者复合语句
{
printf("成年了\n");
printf("可以交⼥朋友了\n");
}
else //else 后使⽤{}控制多条语句-这个块也叫：程序块，或者复合语句
{
printf("未成年\n");
printf("不可以早恋哦\n");
}
return 0;
}1.4 嵌套 if
在 if else 语句中， else 可以与另⼀个 if 语句连⽤，构成多重判断。比如：要求输⼊⼀个整数，判断输⼊的整数是0，还是正数或者负数。请看如下代码：
#include <stdio.h>
int main()
{
int num = 0;
scanf("%d", &num);
if(num == 0)
printf("输⼊的数字是0\n");
else if(num > 0) //这⾥的if 相当于嵌套在els语句中，形成了嵌套结构
printf("输⼊的数字是正数\n");
else
printf("输⼊的数字是负数\n");
return 0;
}如上，else后边接了 if 条件判断，一般这种结构比较少用，还不如直接用 if 条件判断。
1.5 悬空 else 问题
如果有多个 if 和 else ，可以记住这样⼀条规则， else 总是跟最接近的 if 匹配。例如：
int main()
{
int a = 1;
int b = 0;
if (a == 1)
if (b == 2)
printf("hehe\n");
else
printf("haha\n");
return 0;
}以上程序，虽然 else 是和第一个 if 是对齐的，但实际上它是属于第二个 if 结构的。虽然，没有大括号表明程序块，但应该知道，以上程序等价于：
int main()
{
int a = 1;
int b = 0;
if (a == 1)
{
if (b == 2)
printf("hehe\n");
else
printf("haha\n");
}
return 0;
}这就是悬空 else 的问题，如果有多个 if 和 else ，可以记住这样⼀条规则， else 总是跟最接近的 if 匹配。
只要带上适当的⼤括号，代码的逻辑就会更加的清晰，所以⼤家以后在写代码的时候要注意括号的使⽤，让代码的可读性更⾼，尽量使用大括号，代码读起来会很清晰。
2. 关系操作符
C 语⾔⽤于⽐较的表达式，称为 “关系表达式”（relational expression），⾥⾯使⽤的运算符就称为“关系运算符”（relational operator），主要有下⾯6个：
- > ⼤于运算符
- < ⼩于运算符
- >= ⼤于等于运算符
- <= ⼩于等于运算符
- == 相等运算符
- != 不相等运算符
下⾯是⼀些例⼦：
a == b;
a != b;
a < b;
a > b;
a <= b;
a >= b; 关系表达式通常返回 0 或 1 ，表⽰真假。
C 语⾔中， 0 表⽰假，所有⾮零值表⽰真。⽐如， 20 > 12 返回 1 ， 12 > 20 返回 0 。
关系表达式常⽤于 if 或 while 结构。
if (x == 3)
{
printf("x is 3.\n");
}注意：相等运算符 == 与赋值运算符 = 是两个不⼀样的运算符，不要混淆。有时候，可能会不⼩⼼写出下⾯的代码，它可以运⾏，但很容易出现意料之外的结果。易错点一。
if (x = 3) ... 上⾯⽰例中，原意是 x == 3 ，但是不小心写成 x = 3 。这个式⼦表⽰对变量 x 赋值 3 ，它的返回值为 3 ，所以 if 判断总是为真。
为了防⽌出现这种错误，可以把需要做对比的变量写在等号的右边。
if (3 == x) ...
//这样的话，如果把 == 误写成 = ，编译器会报错
//报错
if(3 = x)...另⼀个需要避免的错误是：多个关系运算符不宜连⽤。
i < j < k上⾯⽰例中，连续使⽤两个⼩于运算符。这是合法表达式，不会报错，但是通常达不到想要的结果，即不是保证变量 j 的值在 i 和 k 之间。因为关系运算符是从左到右计算，所以实际执⾏的是下⾯的表达式：
(i < j) < k 上⾯式⼦中， i < j 返回 0 或 1 ，所以最终是 0 或 1 与变量 k 进⾏⽐较。如果想要判断变量 j
的值是否在 i 和 k 之间，应该使⽤下⾯的正确写法：
i < j && j < k例如：我们输⼊⼀个年龄，如果年龄在18岁~36岁之间，我们输出⻘年。
#include <stdio.h>
int main()
{
int age = 0;
scanf("%d", &age);
if(18<=age<=36)
{
printf("⻘年\n");
}
return 0;
}
这是因为，我们先拿 18 和 age 中存放的 10 比较，表达式 18<=10 为假， 18<=age 的结果是0，再拿0和36⽐较，0<=36为真，所以打印了 ⻘年 ，所以即使当age是10的时候，也能打印 ⻘年 ，逻辑上是有问题，这个代码应该怎么写呢？
#include <stdio.h>
int main()
{
int age = 0;
scanf("%d", &age);
if(age>=18 && age<=36)
{
printf("⻘年\n");
}
return 0;
}3. 条件操作符
条件操作符也叫三⽬操作符，需要接受三个操作数的，形式如下：
exp1 ? exp2 : exp3;条件操作符的计算逻辑是：如果 exp1 为真， exp2 计算，计算的结果是整个表达式的结果；如果exp1 为假， exp3 计算，计算的结果是整个表达式的结果。例如：
#include <stdio.h>
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
if (a > 5)
b = 3;
else
b = -3;
printf("%d\n", b);
return 0;
}
//改造后：
#include <stdio.h>
int main()
{
int a = 0;
int b = 0;
scanf("%d", &a);
b = a>5 ? 3:-3;
printf("%d\n", b);
return 0;
}逗号表达式：会从左向右依次计算，但整个表达式的结果是最后一个表达式的结果。例如：
c = 4;
a = (a=3,a+3,b=c*3,c=2*a+b);// a = 184. 逻辑操作符： &&，|| ，！
逻辑运算符提供逻辑判断功能，⽤于构建更复杂的表达式，主要有下⾯三个运算符：
- ！：逻辑取反运算符（改变单个表达式的真假）
- && ：与运算符，就是并且的意思（两侧的表达式都为真，则为真，否则为假）
- ||：或运算符，就是或者的意思（两侧至少有一个表达式为震，则为真，否则为假）
注：C语言中，非0表示真，0表示假
4.1 逻辑取反运算符 ！
比如，我们有⼀个变量叫 flag ,如果flag为假，要做⼀个什么事情，就可以这样写代码：
#include <stdio.h>
int main()
{
int flag = 0;
if(!flag)
{
printf("do something\n");
}
return 0;
}如果 flag 为真， !flag 就是假，如果 flag 为假， !flag 就是真，所以上⾯的代码的意思就是 flag 为假，执⾏if语句中的代码。
4.2 与运算符 &&
&& 就是与运算符，也是并且的意思， && 是⼀个双⽬操作符，使⽤的⽅式是 a&&b , && 两边的表达式都是真的时候，整个表达式才为真，只要有⼀个是假，则整个表达式为假。例如：
int month = 0;
scanf("%d", &month);
if(month >= 3 && month <= 5)
{
printf("春季\n");
}这⾥表达的意思就是month既要⼤于等于3，⼜要⼩于等于5，必须同时满⾜。
4.3 或运算符 ||
|| 就是或运算符，也就是或者的意思， || 也是⼀个双⽬操作符，使⽤的⽅式是 a || b ， ||
两边的表达式只要有⼀个是真，整个表达式就是真，两边的表达式都为假的时候，才为假。例如：
int month = 0;
scanf("%d", &month);
if(month == 12 || month==1 || month == 2)
{
printf("冬季\n");
}4.4 练习：闰年的判断
输⼊⼀个年份year，判断year是否是闰年
闰年判断的规则，1、2是或的关系：
1. 能被4整除并且不能被100整除是闰年
2. 能被400整除是闰年
#include <stdio.h>
//代码1
int main()
{
int year = 0;
scanf("%d", &year);
if(year%4==0 && year%100!=0)
printf("是闰年\n");
else if(year%400==0)
printf("是闰年\n");
return 0;
}
//代码2
int main()
{
int year = 0;
scanf("%d", &year);
if((year%4==0 && year%100!=0) || (year%400==0))
printf("是闰年\n");
return 0;
}4.5 短路
C语⾔逻辑运算符还有⼀个特点，它总是先对左侧的表达式求值，再对右边的表达式求值，这个顺序是保证的。如果左边的表达式满⾜逻辑运算符的条件，就不再对右边的表达式求值。这种情况称为“短路”。如前⾯的代码:
对于 && 操作符是怎么样呢？我们结合前⾯的代码：
if(month >= 3 && month <= 5)表达式中 && 的左操作数是 month >= 3 ，右操作数是 month <= 5 ，当左操作数 month >= 3 的结果是0的时候，即使不判断 month <= 5 ，整个表达式的结果也是0（不是春季）。所以，对于&& 操作符来说，左边操作数的结果是0的时候，右边操作数就不再执⾏。
对于 || 操作符是怎么样呢？我们结合前⾯的代码：
if(month == 12 || month==1 || month == 2)如果 month == 12，则不⽤再判断 month 是否等于 1 或者 2，整个表达式的结果也是1（是冬季）。所以， || 操作符的左操作数的结果不为0时，就⽆需执⾏右操作数。像这种仅仅根据左操作数的结果就能知道整个表达式的结果，不再对右操作数进⾏计算的运算称为短路求值。
经典练习题：
①当a = 0 时， i = a++ && ++b && d++;
int main()
{
int i = 0, a = 0, b = 2, c = 3, d = 4;
i = a++ && ++b && d++;
printf("i = %d\n", i);
//i = a++||++b||d++;
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
return 0;
}a = 1,b = 2,c = 3,d = 4; a原来是0，a++，a = 0先拿来用做与运算，直接把后边两个给短路了，然后 a 再做自增运算，b和d是没有机会做自增运算的。
②当a = 2时， i = a++ && ++b && d++;
int main()
{
int i = 0, a = 2, b = 2, c = 3, d = 4;
i = a++ && ++b && d++;
printf("i = %d\n", i);
//i = a++||++b||d++;
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
return 0;
}a = 3,b = 3,c = 3,d = 5; a原来是2，a++，a = 2先拿来用做与运算，左边成立，判断++b也成立，判断d++都成立，也都做了自增运算。
③当a = 0时， i = a++ || ++b || d++;
int main()
{
int i = 0, a = 0, b = 2, c = 3, d = 4;
i = a++||++b||d++;
printf("i = %d\n", i);
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
return 0;
}a = 1,b = 3,c = 3,d = 4; a原来是0，a++，a = 0先拿来用做或运算，第一个表达式不成立，判断完不成立后，a进行了自增，判断++b成立，b也做了自增，然后就把后边的表达式给短路掉了，d++不做判断也不会进行自增。
③当a = 2时， i = a++ || ++b || d++;
int main()
{
int i = 0, a = 2, b = 2, c = 3, d = 4;
i = a++||++b||d++;
printf("i = %d\n", i);
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
return 0;
}a = 3,b = 2,c = 3,d = 4; a原来是2，a++，a = 2先拿来用做或运算，第一个表达式成立，判断完成立后，a进行了自增，此时就不再对后边的表达式进行判断也不进行自增。
5. switch 语句
除了 if 语句外，C语⾔还提供了 switch 语句来实现分⽀结构。switch 语句是⼀种特殊形式的 if...else 结构，⽤于判断条件有多个结果的情况。它把多重的 else if 改成更易⽤、可读性更好的形式。
switch (expression)
{
case value1: statement
case value2: statement
default: statement
}上⾯代码中，根据表达式 expression 不同的值，执⾏相应的 case 分⽀。如果找不到对应的值，就执⾏ default 分⽀。
注：
switch 后的 expression 必须是整型表达式；
case 后的值，必须是整形常量表达式，变量也不可以。
5.1 switch 语句的用法
#include <stdio.h>
int main()
{
int n = 0;
scanf("%d", &n);
switch(n % 3)
{
case 0:
printf("整除，余数为0\n");
break;
case 1:
printf("余数是1\n");
break;
case 2:
printf("余数是2\n");
break;
}
return 0;
}上述的代码中，我们要注意的点有：
case 和后边的数字之间必须有空格；
每⼀个 case 语句中的代码执⾏完成后，需要加上 break ，才能跳出这个switch语句。
5.2 switch 语句中的break
前⾯的代码中，如果我们去掉case语句中的break，会出现什么情况呢？
#include <stdio.h>
int main()
{
int n = 0;
scanf("%d", &n);
switch(n%3)
{
case 0:
printf("整除，余数为0\n");
case 1:
printf("余数是1\n");
case 2:
printf("余数是2\n");
}
return 0;
}
原因是 switch 语句也是分⽀效果的，只有在 switch 语句中使⽤ break 才能在跳出 switch 语
句，如果某⼀个 case 语句的后边没有 break 语句，代码会继续往下执⾏，有可能执⾏其他 case
语句中的代码，直到遇到 break 语句或者 switch 语句结束。就⽐如上⾯的代码就执⾏了 case
2 中的语句。
switch 语句也可以嵌套 switch 语句，但 break 只能跳出自己的 switch 语句。
5.3 switch 语句中的 default
在使⽤ switch 语句的时候，我们经常可能遇到⼀种情况，⽐如 switch 后的表达式中的值⽆法匹配代码中的 case 语句的时候，这时候要不就不做处理，要不就得在 switch 语句中加⼊default⼦句。主要是用来 处理异常情况。
#include <stdio.h>
int main()
{
int n = 0;
scanf("%d", &n);
switch(n % 3)
{
case 0:
printf("整除，余数为0\n");
break;
case 1:
printf("余数是1\n");
break;
case 2:
printf("余数是2\n");
break;
default:
printf("输入错误\n");
break;
}
return 0;
}当输入的不是case 后边的数时，会执行 default 子语句。
5.4 switch 语句中的 case 和 default 的顺序问题
在 switch 语句中 case ⼦句和 default ⼦句有要求顺序吗？ default 只能放在最后吗？
其实，在 switch 语句中 case 语句和 default 语句是没有顺序要求的，只要你的顺序是满⾜实
际需求的就可以。
不过我们通常是把 default ⼦句放在最后处理的。
case 语句 的顺序是没有要求的，可以按顺序摆放，也可以不按照顺序摆放，同样 default 也可以随意放在任何位置，但为了阅读代码方便，一般都按顺序摆放后，最后放 default 子语句。
6. while 循环
6.1 语法形式
while(表达式)
语句;//如果循环体想包含更多的语句，可以加上大括号6.2 while 语句的执行流程
⾸先上来就是执⾏判断表达式，表达式的值为0，循环直接结束；表达式的值不为0，则执⾏循环语句，语句执⾏完后再继续判断，是否进⾏下⼀次判断。
6.3 while 循环实践
#include <stdio.h>
int main()
{
int i = 1;
while(i<=10)
{
printf("%d ", i);
i = i+1;
}
return 0;
}6.4 练习
输⼊⼀个正的整数，逆序打印这个整数的每⼀位
例如：
输⼊：1234，输出：4 3 2 1
输⼊：521，输出：1 2 5
%10 取余可得最低位；/10 抛弃最低位。
#include <stdio.h>
int main()
{
int n = 0;
scanf("%d", &n);
while(n)
{
printf("%d ", n%10);
n /= 10;
}
return 0;
}7. for 循环
7.1 语法形式
for 循环是三种循环中使⽤最多的， for 循环的语法形式如下：
for(表达式1(初始化);表达式2(判断);表达式3(调整))
语句;//如果循环体想包含更多的语句，可以加上大括号 表达式1 ⽤于循环变量的初始化；
表达式2 ⽤于循环结束条件的判断；
表达式3 ⽤于循环变量的调整。
7.2 for 循环的执行流程
整个循环的过程中，表达式1初始化部分只被执⾏1次，剩下的就是表达式2、循环语句、表达式3在循环。
7.3 for 循环的实践
在屏幕上打印1-10的值
#include<stdio.h>
{
int i = 0;
for(i = 0(1);i <= 10(2);i++(4))
{
printf("%d ",i);(3)
}
return 0;
}for 循环执行顺序：
++i 和 i++ 效果上没有区别，但是，有些说法说 ++i 比 i++ 高效，但在 C 语言中不存在；
在 C++ 中，内置类型也不存在，自定义类型中， ++i 确实比 i++ 高效。
7.4 while 循环和 for 循环的对比
for 和 while 在实现循环的过程中都有初始化、判断、调整这三个部分，但是 for 循环的三个部分⾮常集中，便于代码的维护，⽽如果代码较多的时候 while 循环的三个部分就⽐较分散，所以从形式上 for 循环要更优⼀些。
7.5 练习
计算 1-100 之间3的倍数的数字之和。
#include <stdio.h>
int main()
{
int i = 0;
int sum = 0;
for(i=1; i<=100; i++)
{
if(i % 3 == 0)
sum += i;
}
printf("%d\n", sum);
return 0;
}
//⼩⼩的优化
//如果能直接产⽣3的倍数的数字就省去了多余的循环和判断
#include <stdio.h>
int main()
{
int i = 0;
int sum = 0;
for(i=3; i<=100; i+=3)
{
sum += i;
}
printf("%d\n", sum);
return 0;
}8. do-while 循环
8.1 语法形式
在循环语句中 do while 语句的使⽤最少，它的语法如下：
do
{
语句;
}
while(表达式); while 和 for 这两种循环都是先判断，条件如果满⾜就进⼊循环，执⾏循环语句，如果不满⾜就跳出循环；
⽽ do while 循环则是先直接进⼊循环体，执⾏循环语句，然后再执⾏ while 后的判断表达式，表达式为真，就会进⾏下⼀次，表达式为假，则不再继续循环。注意：while（表达式）后边接有分号。
8.2 do while 循环的执行流程
在 do while 循环中先执⾏图上的“语句”，执⾏完语句，在去执⾏“判断表达式”，判断表达式的
结果是!=0，则继续循环，执⾏循环语句；判断表达式的结果==0，则循环结束。
所以在 do while 语句中循环体是⾄少执⾏⼀次的，这是 do while 循环⽐较特殊的地⽅。
8.3 练习
打印1-10的值
#include <stdio.h>
int main()
{
int i = 1;
do
{
printf("%d ", i);
i = i + 1;
}while(i<=10);
return 0;
}注意while()；有分号
9. break 和 continue 语句
在循环执⾏的过程中，如果某些状况发⽣的时候，需要提前终⽌循环，这是⾮常常⻅的现象。C语⾔中提供了 break 和 continue 两个关键字，就是应该到循环中的。
- break 的作⽤是⽤于永久的终⽌循环，只要 break 被执⾏，直接就会跳出循环，继续往后执⾏循环以外的代码。
- continue 的作⽤是跳过本次循环 continue 后边的代码，在 for 循环和 while 循环中有所差异的。
9.1 while 循环中的 break 和 continue
9.1.1 break 举例
#include <stdio.h>
int main()
{
int i = 1;
while(i<=10)
{
if(i == 5)
break;//当i等于5后，就执⾏break，循环就终⽌了
printf("%d ", i);
i = i+1;
}
return 0;
}执行结果： 1 2 3 4 ，当i = 5 时，执行 break 直接跳出循环，执行循环以外的代码，循环不再进行。
9.1.2 continue 举例
continue 是继续的意思，在循环中的作⽤就是跳过本次循环中 continue 后边的代码，继续进⾏下⼀次循环的判断。
#include <stdio.h>
int main()
{
int i = 1;
while(i<=10)
{
if(i == 5)
continue;
//当i等于5后，就执⾏continue，直接跳过continue的代码，去循环的判断的地⽅
//因为这⾥跳过了i = i+1，所以i⼀直为5，程序陷⼊和死循环
printf("%d ", i);
i = i+1;
}
return 0;
}执行结果： 1 2 3 4 ，当i = 5 时，执行 continue 直接跳过 continue 后边的代码，直接到循环的判断部分进行下一次循环的判断，这里的循环调整在continue后边，循环无法调整，进入了死循环。
到这⾥我们就能分析出来， continue 可以帮助我们跳过某⼀次循环 continue 后边的代码，直接到循环的判断部分，进⾏下⼀次循环的判断，如果循环的调整是在 continue 后边的话，可能会造成死循环。
9.2 for 循环中的 break 和 continue
9.2.1 break 举例
其实和 while 循环中的 break ⼀样， for 循环中的 break 也是⽤于终⽌循环的，不管循环还需
要循环多少次，只要执⾏到了 break ，循环就彻底终⽌。
#include <stdio.h>
int main()
{
int i = 1;
for(i=1; i<=10; i++)
{
if(i == 5)
break;
printf("%d ", i);
}
return 0;
}执行结果： 1 2 3 4 ，当i = 5 时，执行 break 直接跳出循环，执行循环以外的代码，循环不再进行。
9.2.2 continue 举例
#include <stdio.h>
int main()
{
int i = 1;
for(i=1; i<=10; i++)
{
if(i == 5)
continue;//这⾥continue跳过了后边的打印，来到了i++的调整部分
printf("%d ", i);
}
return 0;
}执行结果： 1 2 3 4 6 7 8 9 10 ，当i = 5 时，执行 continue 直接跳过 continue 后边的代码，不进行打印，直接去循环的调整部分。未来当某个条件发⽣的时候，本次循环⽆需再执⾏后续某些操作的时候，就可以使⽤ continue 来实现。
在这⾥我们也可以对⽐⼀下 while 循环和 for 循环中 continue 的区别：
9.3 do while 循环中的 break 和 continue
do while 语句中的 break 和 continue 的作⽤和 while 循环中⼏乎⼀模⼀样，⼤家下来可以
⾃⾏测试并体会：
10. 循环的嵌套
学习了三种循环 while ， do while ， for ，这三种循环往往会嵌套在⼀起才能更好的解决
问题，就是我们所说的：循环嵌套，这⾥我们就看⼀个例⼦。
找出100-200 之间的素数，并打印出来；注：素数⼜称质数，只能被1和本⾝整除的数字。
写程序前的解析：
1. 要从 100~200 之间找出素数，⾸先得有 100~200 之间的数，这⾥可以使⽤循环解决。
2. 假设要判断i是否为素数，需要拿 2~i-1 之间的数字去试除i，需要产⽣ 2~i-1 之间的数字，也可以使⽤循环解决。
3. 如果 2~i-1 之间有数字能整除 i，则 i 不是素数，如果都不能整除，则i是素数。
#include <stdio.h>
int main()
{
int i = 0;
//循环产⽣100~200的数字
for(i=100; i<=200; i++)
{
//判断i是否为素数
//循环产⽣2~i-1之间的数字
int j = 0;
int flag = 1;//假设i是素数
for(j=2; j<i; j++)
{
if(i % j == 0)
{
flag = 0;
break;//这个break只会跳出本个循环体，而无法跳出嵌套它的循环体
}
}
if(flag == 1)
printf("%d ", i);
}
return 0;
}11. goto 语句
C语⾔提供了⼀种⾮常特别的语法，就是 goto 语句和跳转标号， goto 语句可以实现在同⼀个函数内跳转到设置好的标号处。
#include <stdio.h>
int main()
{
printf("hehe\n");
goto next;
printf("haha\n");
next:
printf("跳过了haha的打印\n");
return 0;
}会跳过打印 haha ，到next 标记处，打印 跳过了haha的打印。
goto 语句如果使用的不当，就会导致在函数内部随意乱跳转，打乱程序的执⾏流程，所以我们的建议是能不⽤尽量不去使⽤；但是 goto 语句也不是⼀⽆是处，在多层循环的代码中，如果想快速跳出使⽤ goto 就⾮常的⽅便了。
for(...)
{
for(...)
{
for(...)
{
if(disaster)
goto error;
}
}
}
error:
//...本来 for 循环想提前退出得使⽤ break ，⼀个 break 只能跳出⼀层 for 循环，如果3层循环嵌套就得使⽤3个 break 才能跳出循环，所以在这种情况下我们使⽤ goto 语句就会更加的快捷。
12. 分支和循环 —— 综合实践练习题
写⼀个猜数字游戏
游戏要求：
1. 电脑⾃动⽣成1~100的随机数
2. 玩家猜数字，猜数字的过程中，根据猜测数据的⼤⼩给出⼤了或⼩了的反馈，直到猜对，游戏结束。
12.1 随机数生成
12.1.1 rand 函数
C语⾔提供了⼀个函数叫 rand，这函数是可以⽣成随机数的，函数原型如下所⽰：
int rand (void); rand函数会返回⼀个伪随机数，这个随机数的范围是在0~RAND_MAX之间，RAND_MAX的大小是依赖编译器上实现的，但是⼤部分编译器上是32767。
rand函数的使⽤需要包含⼀个头⽂件是：stdlib.h
那我们就测试⼀下rand函数，这⾥多调⽤⼏次，产⽣5个随机数：
#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("%d\n", rand());
printf("%d\n", rand());
printf("%d\n", rand());
printf("%d\n", rand());
printf("%d\n", rand());
return 0;
}我们先运⾏⼀次，看看结果，再运⾏⼀次再看看结果，多运⾏⼏次呢？
我们可以看到虽然⼀次运⾏中产⽣的5个数字是相对随机的，但是下⼀次运⾏程序⽣成的结果和上⼀次⼀模⼀样，这就说明有点问题。
如果再深⼊了解⼀下，我们就不难发现，其实rand函数⽣成的随机数是伪随机的，伪随机数不是真正的随机数，是通过某种算法⽣成的随机数。真正的随机数的是⽆法预测下⼀个值是多少的。⽽rand函数是对⼀个叫“种⼦”的基准值进⾏运算⽣成的随机数。
之所以前⾯每次运⾏程序产⽣的随机数序列是⼀样的，那是因为rand函数⽣成随机数的默认种⼦是1。如果要⽣成不同的随机数，就要让种⼦是变化的。
12.1.2 srand 函数
C语⾔中⼜提供了⼀个函数叫 srand，⽤来初始化随机数的⽣成器的，srand的原型如下：
void srand (unsigned int seed);
程序中在调⽤ rand 函数之前先调⽤ srand 函数，通过 srand 函数的参数seed来设置rand函数⽣成随机数的时候的种⼦，只要种⼦在变化，每次⽣成的随机数序列也就变化起来了。
那也就是说给 srand 的种⼦是如果是随机的，rand 就能⽣成随机数；在⽣成随机数的时候⼜需要⼀个随机数，这就⽭盾了。
12.1.3 time 函数
在程序中我们⼀般是使⽤程序运⾏的时间作为种⼦的，因为时间时刻在发⽣变化的。
在C语⾔中有⼀个函数叫 time ，就可以获得这个时间，time函数原型如下：
time_t time (time_t* timer);time 函数会返回当前的⽇历时间，其实返回的是1970年1⽉1⽇0时0分0秒到现在程序运⾏时间之间的差值，单位是秒。返回的类型是time_t类型的，time_t 类型本质上其实就是32位或者64位的整型类型。
time函数的参数 timer 如果是⾮NULL的指针的话，函数也会将这个返回的差值放在timer指向的内存中带回去。
如果 timer 是NULL，就只返回这个时间的差值。time函数返回的这个时间差也被叫做：时间戳。time函数的时候需要包含头⽂件：time.h
如果只是让 time 函数返回时间戳，我们就可以这样写：
time(NULL);//调⽤time函数返回时间戳，这⾥没有接收返回值那我们就可以让⽣成随机数的代码改写成如下：
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
//使⽤time函数的返回值设置种⼦
//因为srand的参数是unsigned int类型，我们将time函数的返回值强制类型转换
srand((unsigned int)time(NULL));
printf("%d\n", rand());
printf("%d\n", rand());
printf("%d\n", rand());
printf("%d\n", rand());
printf("%d\n", rand());
return 0;
}每次的运行结果都不一样：
srand函数是不需要频繁调⽤的，⼀次运⾏的程序中调⽤⼀次就够了。
12.1.4 设置随机数的范围
如果我们要⽣成0~99之间的随机数，⽅法如下：
rand() % 100;//余数范围是 0 - 99
如果我们要⽣成1~100之间的随机数，⽅法如下：
rand()%100+1;//%100的余数是0~99,0~99的数字+1,范围是1~100如果我们要⽣成100~200之间的随机数，⽅法如下：
100 + rand()%(200-100+1)
//余数的范围是0~100，加100后就是100~200所以如果要⽣成a~b的随机数，⽅法如下：
a + rand()%(b-a+1)12.2 猜数字游戏实现
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//猜数字游戏 函数
void game()
{
int r = rand()%100+1;//生成1-100之间的随机数
int guess= 0;
while(1)
{
printf("请猜数字>:");
scanf("%d", &guess);
if(guess < r)
{
printf("猜⼩了\n");
}
else if(guess > r)
{
printf("猜⼤了\n");
}
else
{
printf("恭喜你，猜对了\n");
break;
}
}
}
//生成显示菜单
void menu()
{
printf("***********************\n");
printf("****** 1. play ******\n");
printf("****** 0. exit ******\n");
printf("***********************\n");
}
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;
}
1933
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
