2、C语言 循环和分支

 C语⾔是结构化的程序设计语⾔，这⾥的结构指的是 顺序结构、选择结构、循环结构，C语⾔是能够实现这三种结构的，其实我们如果仔细分析，我们⽇常所⻅的事情都可以拆分为这三种结构或者这三种结构的组合。
 我们可以使⽤ if 、 switch实现分⽀结构，使⽤ for 、 while 、 do while实现循环结构。

1、if语句

Ⅰ、if语句的语法形式

if ( 表达式 )
 语句
 //表达式成⽴（为真），则语句执⾏，表达式不成⽴（为假），则语句不执⾏

 在C语⾔中，0为假，⾮0表⽰真，也就是表达式的结果如果是0，则语句不执⾏，表达式的结果如果是不是0，则语句执⾏。
代码块：

#include <stdio.h>
int main()
{
	int num = 0;
	scanf("%d", &num);	//&	是取地址符，取 num的地址数进行运算
	//输⼊⼀个整数，判断是否为奇数
	if (num % 2 == 1)
		// 用户输入的 num 为奇数， 模 2 后余 1 就为真，则就返回数据，反之为假则不返回；
		printf("%d 是奇数\n", num);
	return 0;
}

Ⅱ、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;
}

代码块：

//输⼊⼀个年龄，>= 18岁就输出：成年，否则就输出：未成年
#include <stdio.h>
int main()
{
    int age = 0;
    scanf("%d", &age);
    if (age >= 18)
        printf("成年\n");
    else
        printf("未成年\n");
    return 0;
}

Ⅲ、分支中包含多条语句

 默认 if 和 else 在语句中都只控制⼀条语句。
代码块：

#include <stdio.h>
int main()
{
    int age = 0;
    scanf("%d", &age);
    if (age >= 18)
        printf("成年了\n");
    printf("你需要为自己的行为负责任了！");
    return 0;
}

 上⾯的代码执行，你会发现输⼊的值不管是>=18 还是⼩于18，“你需要为自己的行为负责任了！” 都会打印在屏幕上。
代码效果
 这是因为 if 语句只能控制⼀条语句，就是 printf(“成年了\n”); ，if语句为真，则打印成年了，
if语句为假，则不打印，对于 printf(“你需要为自己的行为负责任了！\n”); 是独⽴存在的，不管 if 语句的条件的真假，都会被执⾏。那如果我们要 if 语句同时控制2条语句，怎么办呢？那就要使⽤ {} 将代码括起来，else 后也可以跟上⼤括号。
代码块：

#include <stdio.h>
int main()
{
    int age = 0;
    scanf("%d", &age);
    if (age >= 18)	//if 后使⽤{} 控制多条语句-这个块也叫：程序块 或者 复合语句
    {
        printf("成年了\n");
        printf("你需要为自己的行为负责任了！");
    }
    else
    {
        printf("你还未成年");
        printf("现在还需要父母的管教！");
    }
    return 0;
}

Ⅳ、嵌套 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 代码就是嵌套在后⾯的 else ⼦句中的，构成了嵌套的 if 语句。
例如
 要求输⼊⼀个整数，如果是正数，再判断是奇数还是偶数，并输出；如果不是正数则输出不是整数。
代码块：

#include <stdio.h>
int main()
{
	int num = 0;
	scanf("%d", &num);
	if (num > 0)
	{
	//{
		if (num % 2 == 0)
			printf("偶数\n");
		else
			printf("奇数\n");
	//}
	}
	else
	{
		printf("输⼊的值是负数\n");
	}
	return 0;
}

 上⾯的代码中 注释 {} 的代码也是嵌套在 if 语句中的，构成了嵌套的 if 语句。

Ⅴ、悬空else问题

 如果有多个 if 和 else ，可以记住这样⼀条规则， else 总是跟最接近的 if 匹配。
代码块：

#include <stdio.h>
int main()
{
	int a = 0;
	int b = 2;
	if (a == 1)
		if (b == 2)
			printf("hello\n");
	else
		printf("world\n");
	return 0;
}

代码效果

 如果上来就判断 a 是 0，不等于 1 ，那就执⾏ else ⼦句，打印 “world”；
 但是当你去运⾏代码时，会发现输出的结果是：啥都不输出。

 这就是悬空 else 的问题，如果有多个 if 和 else ，可以记住这样⼀条规则， else 总是跟最接近的 if 匹配。
 上⾯的代码排版，让 else 和第⼀个 if 语句对⻬，让我们以为 else 是和第⼀个 if 匹配的，当 if 语句不成⽴的时候，⾃然想到的就是执⾏ else ⼦句，打印 “world” ，但实际上 else 是和第⼆个 if 进⾏匹配的，这样后边的 if…else 语句是嵌套在第⼀个 if 语句中的，如果第⼀个 if 语句就不成⽴，嵌套 if 和 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;
}

 只要带上适当的⼤括号，代码的逻辑就会更加的清晰，所以写代码的时候要注意括号的使⽤，让代码的可读性更⾼!!!

2、关系操作符

 C 语⾔⽤于⽐较的表达式，称为关系表达式，表达式⾥⾯使⽤的运算符就称为关系运算符；
主要有下⾯6个：

操作符	作用
>	⼤于运算符
<	⼩于运算符
>=	⼤于等于运算符
<=	⼩于等于运算符
==	相等运算符
!=	不相等运算符

 关系表达式通常返回 0 或 1 ，表⽰真假。
 C 语⾔中， 0 表⽰假，所有⾮零值表⽰真。⽐如， 20 > 12 返回 1 (真) ， 12 > 20 返回 0 (假)。

关系表达式常⽤于 if 或 while 结构。
代码块：

#include<stdio.h>
int main()
{
	int a = 0;
	if ( a < 10)
	{
		printf("a 小于 10 进行增加\n");
		while (a != 10)
		{
			a++;
			printf("此时 a 的大小为：%d\n", a);
		}
		printf("a 此时的数值为：%d\n", a);
	}
	return 0;
}

代码效果

注意：相等运算符 == 与 赋值运算符 = 是两个不⼀样的运算符，不要混淆。

代码块：

#include<stdio.h>
int main()
{
	int a = 0;
	if (a = 10)	// 走进判断，判断里的条件直接对 a 进行赋值，让 a = 10，
				//导致a == 0 的判断不成立，所以不会打印 a == 0 的结果
	{
		printf("%d", a);
	}

	if (a == 0)//正常书写“==”，当a == 0 时会打印出相应的值
	{
		printf("%d",a);
	}
	return 0;
}

代码效果

 我们预期是想对 a 进行判断，判断 a == 10 的条件，就因为少写一个 = ，让 a 被赋值，它的返回值为 10 ，所以 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;
}

 当我们输⼊10 的时候，依然输出⻘年。

 这是因为，我们先拿 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、逻辑操作符：&& , || , ！

 逻辑运算符提供逻辑判断功能，⽤于构建更复杂的表达式，主要有下⾯三个运算符。

逻辑操作符	详情
!	逻辑取反运算符（改变单个表达式的真假）。
&&	与运算符，就是并且的意思（两侧的表达式都为真，则为真，否则为假）。
||	或运算符，就是或者的意思（两侧⾄少有⼀个表达式为真，则为真，否则为假）。

注：C语⾔中，⾮0表⽰真，0表⽰假

Ⅰ、逻辑取反运算符

 我们有⼀个变量叫 flag ,如果 flag 为假，要做⼀个什么事情：

if (!flag)
{
	printf("hello CSDN\n");
}

 如果 flag 为真， !flag 就是假，如果 flag 为假， !flag 就是真；所以上⾯的代码的意思就是 flag 为假，执⾏if语句中的代码。因为 ’ ! ’是逻辑取反操作符，取的是相反的结果。

Ⅱ、与运算符

 && 就是与运算符，也是并且的意思， && 是⼀个双⽬操作符，使⽤的⽅式是 a&&b , && 两边的表达式都是真的时候，整个表达式才为真，只要有⼀个是假，则整个表达式为假。

⽐如：如果我们说⽉份是3⽉到5⽉，是春天，用代码实现。

#include<stdio.h>
int main()
{
	int month = 0;
	scanf("%d", &month);
	if (month >= 3 && month <= 5)//条件同时满足的时候才输出结果
	{
		printf("春季\n");
	}
	return 0;
}

Ⅲ、或运算符

 || 就是或运算符，也就是或者的意思， || 也是⼀个双⽬操作符，使⽤的⽅式是 a || b ， || 两边的表达式只要有⼀个是真，整个表达式就是真，两边的表达式都为假的时候，才为假。

⽐如：我们说⼀年中⽉份是12⽉或者1⽉或者2⽉是冬天，用代码实现。

#include<stdio.h>
int main()
{
	int month = 0;
	scanf("%d", &month);
	if (month == 12 || month == 1 || month == 2)
	{
		printf("冬季\n");//只要输入的满足其中一条条件就会进行打印
	}
	return 0;
}

Ⅳ、短路

 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时，就⽆需执⾏右操作数。(只要一个为真，结果就是真)

4、switch语句

 除了 if 语句外，C语⾔还提供了 switch 语句来实现分⽀结构。
 switch 语句是⼀种特殊形式的 if…else 结构，⽤于判断条件有多个结果的情况。它把多重的 else if 改成更易⽤、可读性更好的形式。

	switch (expression) //条件语句
	{
		case value1(需满足的条件语句): 执行语句
 		case value2(需满足的条件语句): 执行语句
 		default: 执行语句		//当条件都不满足的时候执行的语句
	}

 上⾯示例中，根据表达式 expression 不同的值，执⾏相应的 case 分⽀。如果找不到对应的值，就执⾏ default 分⽀。
注：
 • switch 后的 expression 必须是整型表达式
 • case 后的值，必须是整形常量表达式

Ⅰ、if语句和switch语句的对⽐

示例：输⼊任意⼀个整数值，计算除3之后的余数
 如果使⽤if语句完成：

#include <stdio.h>
int main()
{
	int n = 0;
	scanf("%d", &n);
	if (n % 3 == 0)
		printf("整除，余数为0\n");
	else if (n % 3 == 1)
		printf("余数是1\n");
	else
		printf("余数是2\n");
	return 0;
}

 如果使⽤switch语句完成：

#include <stdio.h>
int main()
{
	int n = 0;
	scanf("%d", &n);
	switch (n % 3)
	{
	case 0:
		printf("整除，余数为0\n");
		break;	//每⼀个 case 语句中的代码执⾏完成后，需要加上 break 
				//这样才能跳出这个switch语句。
	case 1:
		printf("余数是1\n");
		break;
	case 2:
		printf("余数是2\n");
		break;
	}
	return 0;
}

 注意：

1. case 和后边的数字之间必须有空格。
2. 每⼀个 case 语句中的代码执⾏完成后，需要加上 break ，才能跳出这个switch语句。

Ⅱ、switch语句中的break

 前⾯的代码中，我们对 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;
}

 7 除以 3 本来余数是 1 ，但是程序运⾏的结果多了⼀⾏“余数是2”的打印。
 原因是 switch 语句也是分⽀效果的，只有在 switch 语句中使⽤ break 才能在跳出 switch 语句，如果某⼀个 case 语句的后边没有 break 语句，代码会继续玩下执⾏，有可能执⾏其他 case语句中的代码，直到遇到 break 语句或者 switch 语句结束。

 所以在 switch 语句中 break 语句是⾮常重要的，能实现真正的分⽀效果。break 也不是每个 case 语句都得有，需根据具体情况进行判断。

使用 switch 分支语句完成以下题目：

输⼊⼀个1~7的数字，打印对应的星期⼏
例如：
输⼊：1 输出：星期⼀
输⼊：2 输出：星期⼆
输⼊：3 输出：星期三
输⼊：4 输出：星期四
输⼊：5 输出：星期五
输⼊：6 输出：星期六
输⼊：7 输出：星期天

#include <stdio.h>
int main()
{
	int day = 0;
	scanf("%d", &day);
	switch (day)
	{
		case 1:
			printf("星期一\n");
			break;
		case 2:
			printf("星期⼆\n");
			break;
		case 3:
			printf("星期三\n");
			break;
		case 4:
			printf("星期四\n");
			break;
		case 5:
			printf("星期五\n");
			break;
		case 6:
			printf("星期六\n");
			break;
		case 7:
			printf("星期天\n");
			break;
		//同时也能对题目进行扩展，输入1-5打印结果为工作日
			//输入6-7打印结果为休息日
		/*	修改后的代码
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			printf("工作日\n");
			break;
		case 6:
		case 7:
			printf("休息日\n");
			break;
		*/
	}
	return 0;
}

Ⅲ、switch语句中的default

 在使⽤ switch 语句的时候，我们经常可能遇到⼀种情况，⽐如 switch 后的表达式中的值⽆法匹配代码中的 case 语句的时候，这时候要不就不做处理，要不就得在 switch 语句中加⼊ default ⼦句。

	switch (expression) //条件语句
	{
		case value1(需满足的条件语句): 执行语句
 		case value2(需满足的条件语句): 执行语句
 	default: 执行语句		//当条件都不满足的时候执行的语句
	}

 switch 后边的 expression 的结果不是 value1 ，也不是 value2 的时候，就会执⾏default ⼦句。
 就⽐如前⾯做的打印星期的题目，如果 day 的输⼊不是1~7的值，如果我们要提⽰：输⼊错误，就可以进行修改：

#include <stdio.h>
int main()
{
	int day = 0;
	scanf("%d", &day);
	switch (day)
	{
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			printf("工作日\n");
			break;
		case 6:
		case 7:
			printf("休息日\n");
			break;
		default:		//处理不合规的数据
			printf("输⼊错误\n");
			break;
	{
	return 0;
}

Ⅳ、switch语句中的case和default的顺序问题

 在 switch 语句中 case ⼦句和 default ⼦句有要求顺序吗？ default 只能放在最后吗？
 其实，在 switch 语句中 case 语句和 default 语句是没有顺序要求的，只要你的顺序是满⾜实际需求的就可以。
 不过我们通常是把 default ⼦句放在最后处理错误数据或不满足上述条件的数据的。

5、while循环

 C语⾔提供了3种循环语句， while 就是其中⼀种，while 语句的语法结构和 if 语句⾮常相似。

Ⅰ、if 和 while的对⽐

	if(表达式)
 		语句;
 
 
	while(表达式)
 		语句;//如果循环体想包含更多的语句，可以加⼤括号

//	if 和 while 的对比

//	if 的举例
#include <stdio.h>
int main()
{
	if (1)	//	1 是 非0 所以判断直接通过进行打印 
		printf("hello\n"); //if后边条件满⾜，打印⼀次hello
	return 0;
}

//	while 的举例
#include <stdio.h>
int main()
{
	while (1)
		printf("hello\n"); //while后边的条件满⾜，死循环进行打印hello
	return 0;
}

 这就是他们俩之间的区别，while语句是可以实现循环的效果。

Ⅱ、while语句的执⾏流程

 ⾸先上来就是执⾏判断表达式，表达式的值为0，循环直接结束；表达式的值不为0，则执⾏循环语句，语句执⾏完后再继续判断，是否进⾏下⼀次判断（判断是否为0）。

Ⅲ、while循环的实践

 习题：运用 while 在屏幕上打印1~10的整数

#include <stdio.h>
int main()
{
	int i = 1;
	while (i <= 10)	//满足条件进入循环，不满足退出循环
	{
		printf("%d ", i);
		i = i + 1;
	}
	return 0;
}

6、for循环

Ⅰ、语法形式

 for 循环是三种循环中使⽤最多的， for 循环的语法形式如下：

for(表达式1; 表达式2; 表达式3)
		
		语句；//如果循环体想包含更多的语句，可以加上⼤括号

 表达式1：⽤于循环变量的初始化
 表达式2：⽤于循环结束条件的判断
 表达式3：⽤于循环变量的调整

Ⅱ、for循环的执⾏流程

 ⾸先执⾏ 表达式1 初始化循环变量，接下来就是执⾏ 表达式2 的判断部分；
 表达式2 的结果如果 ==0(假) ，则循环结束；
 表达式2 的结果如果 !=0(真) 则执⾏循环语句，循环语句执⾏完后；
 再去执⾏ 表达式3 ,调整循环变量，然后再去 表达式2 的地⽅执⾏判断， 表达式2 的结果是否为0，决定循环是否继续。
 整个循环的过程中，表达式1初始化部分只被执⾏1次，剩下的就是表达式2、循环语句、表达式3在循环。

Ⅲ、for循环的实践

 习题：在屏幕上打印1~10的值

#include <stdio.h>
int main()
{
	int i = 0;
	//由：初始化；  判断； 变量的调整，三个变量组成
	for (i = 1; i <= 10; i++)	//注意，for 循环之间的表达式用 ; 隔开
	{
		printf("%d ", i);
	}
	return 0;
}

Ⅳ、while循环和for循环的对⽐

//	while循环语句
#include <stdio.h>
int main()
{
	int i = 1;	// 变量初始化
	while (i <= 10) //变量的判断
	{
		printf("%d ", i);
		i = i + 1;	//变量的调整
	}
	return 0;
}
//	for循环语句
#include <stdio.h>
int main()
{
	int i = 0;
	//由：初始化；  判断； 变量的调整，三个变量组成
	for (i = 1; i <= 10; i++)	//注意，for 循环之间的表达式用 ; 隔开
	{
		printf("%d ", i);
	}
	return 0;
}

 for 和 while 在实现循环的过程中都有初始化、判断、调整这三个部分，但是 for 循环的三个部分⾮常集中，便于代码的维护，⽽如果代码较多的时候 while 循环的三个部分就⽐较分散，所以从形式上 for 循环要更优⼀些。

7、do-while循环

Ⅰ、语法形式

 在循环语句中 do while 语句的使⽤最少，它的语法如下：

do
 语句；
while(表达式)；

 while 和 for 这两种循环都是先判断，条件如果满⾜就进⼊循环，执⾏循环语句，如果不满⾜就跳出循环；
 ⽽ do while 循环则是先直接进⼊循环体，执⾏循环语句，然后再执⾏ while 后的判断表达式，表达式为真，就会进⾏下⼀次，表达式为假，则不再继续循环。

Ⅱ、do while循环的执⾏流程

 在 do while 循环中先执⾏图上的 “语句”，执⾏完语句，在去执⾏“判断表达式”，判断表达式的结果是 !=0，则继续循环，执⾏循环语句；判断表达式的结果 ==0 ，则循环结束。
 所以在 do while 语句中循环体是⾄少执⾏⼀次的，这是 do while 循环⽐较特殊的地⽅。

Ⅲ、do while循环的实例

 习题：在屏幕上打印1~10的值

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

	return 0;
}

 ⼀般 do while 使⽤在循环体⾄少被执⾏⼀次的场景下，所以使用较少。

8、break和continue语句

 在循环执⾏的过程中，如果因为某些不必要的状态发生，需要提前终⽌循环，这是⾮常常⻅的现象。C语⾔中提供了 break 和 continue 两个关键字，可以运用到循环中。

1. break 的作⽤是⽤于永久的终⽌循环，只要 break 被执⾏，就会跳出循环，程序往后继续执⾏。
2. continue 的作⽤是跳过本次循环 continue 后边的代码，在 for 循环和 while 循环中实现有所差异。

Ⅰ、while循环中的break和continue

① break举例

//打印到数值 5 就停止 
#include<stdio.h>
int main()
{
	int i = 0;
	while (i<10)
	{
		i++;
		printf("i 的数值：%d\n",i);
		//	打印结果:1 2 3 4 5
		if (i == 5)
			break;

	}
	return 0;
}

 打印了1,2,3,4,5后，当 i 等于 5 的时候，循环在 break 的地⽅终⽌，不再打印，不再继续循环。所以 break 的作⽤就是永久的终⽌循环，只要 break 被执⾏，有 break 的循环层的就终⽌了。那以后我们在循环中，想在某种条件下终⽌循环，则可以使⽤ break 来完成我们想要的效果。

② continue举例

 continue 是继续的意思，在循环中的作⽤就是跳过本次循环中 continue 后边的代码，继续进⾏下⼀次循环的判断。

//连续打印到数值 5 
#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);
		//打印结果：1 2 3 4 5 5 5 5 .....
		i = i + 1;
	}
	return 0;
}

 到这⾥我们就能分析出来， continue 可以帮助我们跳过某⼀次循环中 continue 后边的代码，直接到循环的判断部分，进⾏下⼀次循环的判断，如果循环的调整是在 continue 后边的话，可能会造成死循环。

Ⅱ、for循环中的break和continue

① break举例

 其实和 while 循环中的 break ⼀样， for 循环中的 break 也是⽤于终⽌循环的，不管循环还需要循环多少次，只要执⾏到了 break ，循环就彻底终⽌。

#include<stdio.h>
int main()
{
	for (int i = 1; i < 10; i++)
	{
		printf("此时的 i = %d\n", i);
		if (i == 5)//	对 i = 5 的时候停止打印数值
		{
			printf("此时的 i = %d\n", i);
			//	打印结果:1 2 3 4 5
			break;
		}
	}
	return 0;
}

② continue举例

 在 for 循环中 continue 的作⽤是跳过本次循环中 continue 后的代码，直接去到循环的调整部分。未来当某个条件发⽣的时候，本次循环⽆需再执⾏后续某些操作的时候，就可以使⽤continue 来实现。

#include<stdio.h>
int main()
{
	for (int i = 1; i < 10; i++)
	//因为 for 的自增条件是在循环条件体内部的，所以不会受影响从而循环打印
	{
		if(i == 5)//
			continue;
		printf("此时的 i = %d\n", i);
		//打印结果：1 2 3 4 6 7 8 9
		//因为循环执行到 if 判断是否为 5 ，为 5 后就跳过后面的打印代码，重新回循环进行判断
	}
	return 0;

}

Ⅲ、do while循环中的break和continue

 do…while 语句中的 break 和 continue 的作⽤和 while 循环中⼏乎⼀模⼀样。

 do…while 的 break 代码实现：

#include<stdio.h>
int main()
{
	int i = 0;
	do
	{
		i++;
		printf("i 的数值：%d\n", i);
		//	打印结果:1 2 3 4 5
		if (i == 5)
			break;

	} while(i<10);

	return 0;
}

 do…while 的 continue 代码实现：

int main()
{
	int i = 0;
	do
	{
		i++;
		if (i == 5)
			continue;
		printf("i 的数值：%d\n", i);
		//打印结果：1 2 3 4 6 7 8 9
	} while (i < 10);

	return 0;
}

9、循环的嵌套

 三种循环 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++)//为什么从 2 开始判断，因为能被 1 和 自身整除,
							   //加上 1 就会多 100 个判断，从而增加计算量； 
		{
			if (i % j == 0)
			{
				flag = 0;
				break;
			}
		}
		if (flag == 1)
			printf("%d ", i);
	}
	return 0;
}

10、goto语句

 C语⾔提供了⼀种⾮常特别的语法，就是 goto 语句和跳转标号， goto 语句可以实现在同⼀个函数内跳转到设置好的标号处。

#include <stdio.h>
int main()
{
	printf("hello\n");
	goto next;
	printf("world\n");

next:
	printf("跳过了world的打印\n");
	return 0;
}

 goto 语句如果使⽤的不当，就会导致在函数内部随意乱跳转，打乱程序的执⾏流程，所以我们的建议是能不⽤尽量不去使⽤；但是 goto 语句也不是⼀⽆是处，在多层循环的代码中，如果想快速跳出就可以使用 goto 语句。

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

 本来 for 循环想提前退出得使⽤ break ，⼀个 break 只能跳出⼀层 for 循环，如果3层循环嵌套就得使⽤ 3个 break 才能跳出循环，所以在这种情况下我们使⽤ goto 语句就会更加的快捷。

11、随机数生成

Ⅰ、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。
 如果要⽣成不同的随机数，就要让种⼦是变化的。

Ⅱ、srand 函数

 C语⾔中⼜提供了⼀个函数叫 srand，⽤来初始化随机数的⽣成器的，srand的原型如下：

 	void srand (unsigned int seed);

 程序中在调⽤ rand 函数之前先调⽤ srand 函数，通过 srand 函数的参数seed来设置 rand 函数⽣成随机数的时候的种⼦，只要种⼦在变化，每次⽣成的随机数序列也就变化起来了。
 那也就是说给 srand 的种⼦是如果是随机的，rand就能⽣成随机数；在⽣成随机数的时候⼜我们提供需要⼀个随机数，这就⽭盾了。

Ⅲ、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);

此时的随机生成数字的代码就可以改写成这样：

#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函数是不需要频繁调⽤的，⼀次运⾏的程序中调⽤⼀次就够了。

Ⅳ、设置随机数的范围

 1、如果我们要⽣成0~99之间的随机数，⽅法如下：

	rand() %100;	//余数的范围是0~99

 2、如果要⽣成1~100之间的随机数，⽅法如下：

	rand()%100+1;	//%100的余数是0~99,0~99的数字+1,范围是1~100

 3、如果要⽣成100~200的随机数，⽅法如下：

	100 + rand()%(200-100+1) 	//余数的范围是0~100，加100后就是100~200

 4、所以如果要⽣成a~b的随机数，⽅法如下：

	a + rand()%(b-a+1)