demo16 计算年份是否为闰年（各种运算符结合）

案例描述：

每年二月份的天数不是固定不变的
闰年时，二月天数为29天；非闰年时，二月天数为28天
判断是否为闰年，满足两个条件之一即可：1、年份可以被4整除但是不能被100整除；2、年份能够被400整除

实现过程：

声明变量year，并在终端输入
判断是否可以被400整除，如果可以则为闰年，否则执行第一个条件判断

代码：

/* demo16 计算年份是否为闰年（各种运算符结合） */
#include<iostream>

using namespace std;

int main() {
	int year;
	cin >> year;		//输入年份
	//因为定义的year是整型的，所以输入的时候会自动转换为整型，因此不需要判断输入的数据是否正确。
	if (year % 400 == 0)						//如果能被 400 整除，则为闰年
	{
		cout << year << "年是闰年" << endl;
	}
	else										//不能被 400 整除
	{
		if ((year % 4 == 0) && (year % 100 != 0))//判断闰年的另一个条件
		{
			cout << year << "年是闰年" << endl;	
		}
		else
		{
			cout << year << "年不是闰年" << endl;
		}
	}
	return 0;
}

运行结果：

代码解析：

• 第 07 行表示用户输入被判断的年份值
• 第 08～16 行表示判断所输的值能否满足上述两个条件之一
• 第 08、09 行表示是否满足第 2 个条件，第 10～16 行表示是否满足第 1 个条件
• 上述两个条件并不是呈互相排斥关系，所以在 else 结构中必须还要有 if 条件的判断。

demo17 打印ASCII码表

ASCII表：

案例描述：

在C++中，ASCII码经常被使用，它的作用是将字符、数字、标点转换成计算机能够识别的二进制编码。
一般ASCII表分为非打印控制字符和打印字符两种
在计算机中存储时，是用8位二进制数表示的
本案例为了便于观察，使用十进制代替二进制文字
ASCII表中，有128个码（从0～127），其中0～31是非打印控制字符；48～57是10个阿拉伯数字；65～90是26个大写的英文字母；97～122表示26个小写的应为字母；其余的全部都是标点符号。

实现过程：

打印整个ASCII表，打印时每列有16个ASCII码
打印语句的格式：十进制数字 = 对应的ASCII码 ｜
ASCII码表中，代表转义字符的表都可以直接进行转义字符的输出

代码：

/* 打印ASCII码表 */

#include<iostream>

using namespace std;
int main() {
	int i = 0;
	for (int rows = 0; rows < 16; rows++)				//一共输出16行
	{
		i = rows;
		while (i <= 127)								//一共有1278个字符，因此输出循环结束的条件就是输出结束
		{
			switch (i)									//转义字符可以进行直接输出
			{
			case 7:
				cout << i << "=" << " \\a" << " | ";
				break;
			case 8:
				cout << i << "=" << " \\b" << " | ";
				break;
			case 9:
				cout << i << "=" << " \\t" << " | ";
				break;
			case 10:
				cout << i << "=" << " \\n" << " | ";
				break;
			case 11:
				cout << i << "=" << " \\v" << " | ";
				break;
			case 12:
				cout << i << "=" << " \\f" << " | ";
				break;
			case 13:
				cout << i << "=" << " \\r" << " | ";
				break;
			default:
				cout << i << "=" << char(i) << " | ";	//非转移字符的输出
				break;
			}
			i += 16;									//输出的每行的的相邻之间差16
		}
		cout << endl;									//每行结尾输出换行
	}
	return 0;
}

运行结果：

代码解析：

第 07 行表示每列打印 16 个 ASCII 码，for 循环中嵌套 while 循环，用于打印所有的 ASCII 码。
对于 7 个转义字符的打印，使用 switch 结构选择打印（第 12～38 行）。
第 40 行表示在当 前行中，前一个元素比后一个元素相差 16。

注意：
因为0~31是非打印控制字符，所以没有打印出来。

demo18 求完数

案例描述：

判断一个数是否为完数
完数必须满足两个条件：1.完数必须是自然数；2.他所有的真因子的和等于它本身；（真因子：除了自身之外的所有乘数）

实现过程：

先声明一个变量，用于放入输入的值；
初始化一个指针，指针指向存放真因子的数组（因为不知道真因子有多少，为了不使）；
利用取余数的操作，获取数值的所有真因子（所有的自然数都有一个数值为1的真因子，因此可以将数组的第一个位置设置为1）；
验证是否为完数
释放内存

代码：

#include <iostream>
using namespace std;

int main()
{
	int shu;										//变量数字
	cout << "请输入一个任意的自然数：" << endl;
	cin >> shu;										//输入数字
	//求输入数字的所有真因子
	int* zhen_yinzi = new int[shu];					//不知道真因子有多少个，所以用指针指向
	int index = 0;									//个数索引变量，初始化为 0 
	int sum = 0;									//所有真因子的总和
	zhen_yinzi[0] = 1;								//所有数字都有一个真因子为 1 
	for (int i = 2; i < shu; i++)					//循环查找所有的因子
	{
		if (shu % i == 0)							//表示该因子为真因子
		{
			index++;
			zhen_yinzi[index] = i;
		}
	}
	
	 for (int j = 0; j <= index; j++)				//将所有的真因子相加
	 {
		sum += zhen_yinzi[j];
	 }
	 delete[] zhen_yinzi;							//释放内存
	 zhen_yinzi = NULL;
	
	 if (sum == shu)								//如果真因子之和等于数字本身，即为完数
		cout << "数字" << shu << "是完数" << endl;
	 else
		cout << "数字" << shu << "不是完数" << endl;
	
	 return 0;
}

运行结果：

代码解析：

第 06～13 行用来声明各种变量，并将真因子 zhen_yinzi 的第 1 个元素赋值为 1。
第 04～21 行用于计算 shu 的所有真因子。
一个数一定会被因子整除，所以 for 循环的判断范围为 2 到 shu， 判断条件为 shu 被当前值 i整除（如第 16 行）。
第 23～26 行用于把所有的真因子相加，第 30 行判断相加之和是否等于 shu 的值。

注意：第 27、28 行是释放指针内存，在用 new 申请内存时，必须在程序结尾包含这句代码，否则会出现内存泄漏或野指针。

demo19 密码验证（if……else）

案例描述：

在设置登陆系统的时候，我们需要判断用户密码是否正确
使用if……else来判断输入的密码是否正确

实现过程：

定义输入密码的变量，此时需要定义string类型；
在本案例中，设置一个宏定义常量，讲输入变量与此常量进行比较
利用判断语句进行判断

代码：

#include<iostream>
using namespace std;

#define Code "123456"		//在案例中固定一个密码

int main() {
	string input_code;		//设置输入变量
	cout << "请输入密码：" << endl;
	

	while (true)			//设定一个循环，当输入错误是，提示继续输入，知道输出正确跳出，跳出语句设置在循环内部
	{
		cin >> input_code;
		if (input_code == Code)
		{
			cout << "恭喜密码验证成功！" << endl;	//提示密码输入成功
			break;									//密码输入成功跳出循环
		}
		else
		{
			cout << "密码输入错误，请重新输入密码：" << endl;	//密码输入错误，给出提示并继续输入
			
		}
	}
	return 0;
}

运行结果：

代码解析：

第 04 行使用宏定义常量 Code 用于表示字符“123456”。
while循环体中对密码是否正确进行判断，不断输入，直到输入正确
也可以使用for循环来控制输入次数，比如你只有十次的机会。设置循环判断是小于10

#defne定义的常量语句不能加分号

demo20 图书管理（if…else if…else）

案例描述：

图书馆中存有很多书籍，这些书籍又有各自的分类及名称，所以涉及如何快速查询想要借阅的图书。
另外，借书和还书是图书馆的两大基本功能。
针对此问题，当前图书的状态信息是一项很重要的功能实现。本实例基于控制台程序实现图书管理的基本功能演示，

实现过程：

本实例实现的图书管理功能包括以下几大模块：

	 - 借书功能管理。 
	 - 还书功能管理。 
	 - 图书分类管理。  
	 - 图书基本信息管理。 
	 - 当前图书状态查询功能。  
	 - 退出。

针对用户输入的功能编号，界面会弹出进入对应模块的提示语句

代码：

#include<iostream>
using namespace std;

int main() {
	// 先输出系统的各种功能
	cout << "图书管理系统功能" << endl
		<< "1-借书功能管理" << endl
		<< "2-还书功能管理" << endl
		<< "3-图书分类管理" << endl
		<< "4-图书基本信息管理" << endl
		<< "5-当前图书状态查询功能" << endl
		<< "0-退出" << endl;
	int choose;			//设置选择变量
	int count = 10;		//限制最多可执行10次

	while (count >= 0)
	{
		cout << "请输入您当前的选择：" << endl;
		cin >> choose;
		// 判断用户会进入哪个模块
		if (choose == 0)
		{
			cout << "成功退出系统" << endl;
			break;
		}
		else if (choose == 1)
			cout << "您已进入结束功能管理模块！" << endl;
		else if (choose == 2)
			cout << "您已进入还书功能管理模块！" << endl;
		else if (choose == 3)
			cout << "您已进入图书分类管理模块！" << endl;
		else if (choose == 4)
			cout << "您已进入图书基本信息管理模块！" << endl;
		else if (choose == 5)
			cout << "您已进入当前图书状态查询功能模块！" << endl;
		else
			cout << "请选择正确的功能！！！" << endl;		//提示未选择正确的功能模块
		count--;
	}
	return 0;
}

运行结果：

代码解析：

6～12 行给出了图书管理系统的提示语句，整型变量 status 表示当前用户的选择，整型变量 count 表示用户可以重复多少次做出选择；
16～37 行为 while 循环结构；
21～35 行使用 if…else if…else 结构判断用户当前的选择，并进入相应的模块；
21～25 行给出当选择为 5 时，需要退出系统；
24 行 如果循环次数没有达到 count 次，系统会强制退出。

• 代码中的 if…else if…else 结构可以用 switch 结构代替
• 此案例可以使用类来实现，会使得代码更加健壮，后面学习会涉及到
• 判断语句同样可以使用swich来实现

demo21 信号灯（++和–）

案例描述：

信号灯的应用目的是向指定的人发出警报，如在大海上航行的船只、在天上飞行的飞机等，当这些物体在移动的过程中遇到危险时，地面的工作者会提前收到提醒，比如使用信号灯做提示。
信号灯在工作的时候都会一灭一亮的，现规定如果计数次数为偶，则呈亮的状态，如果计数次数为奇，则呈灭的状态。

实现过程：

使用运算符++做辅助
首先定义一个整型变量 count 作为计数次数
然后用 for 循环判断当前 count 是偶还是奇
信号灯的最初状态为“灭”

代码：

#include<iostream>
using namespace std;

int main() {
	int count = 1;
	cout << "灭" << endl;			//初始状态设置为灭
	for (; count < 10; )
	{
		//int a = count++;					//++在后面
		int a = ++count;					//++在前面
		if (a % 2 == 0)
		{
			cout << "亮" << endl;			//偶数时灯亮
		}
		else
			cout << "灭" << endl;			//偶数时灯灭
	}
}

运行结果：

代码解析：

6 行声明变量 count
7 行输出信号灯的最初状态
8～16 行为 for 循环，用于判断信号灯当前应该是亮还是灭
10、11 行是将当前的 count 值赋给变量 a，目的是判断位于变量后的++与位于变量前的++有何不同。如果++位于变量后当前参与运算的 a 值先加 1，再参与运算。它的运行结果当前参与运算的 a 值并没有发生相应的变化，即先运算，再加 1。如果++位于变量前，即a = ++count; 当前参与运算的 a 值先加 1，再参与运算。

运算符–的运算规则和运算符++的规则类似
在前面——先赋值再运算；在后面——先运算再赋值

demo22 简单地获取变量的字节大小（sizeof）

案例描述：

在 C++语言中获取变量的字节大小有一个特定的函数，即 sizeof()。输入参数是所要获取字节大小的变量，可以是数据类型（如 int、float等），也可以是变量名称。
演示如何获取一个变量的字节大小，程序的输入参数是变量名称，

实现过程：

本实例的目的是实现获取变量所占内存的字节大小，此处定义 1 个整型变量 a，1 个整型变量用于存储 a 的字节大小。
获取变量的字节大小格式如: 字节大小 = sizeof(变量)；

代码：

#include<iostream>
using namespace std;
int main() {
	int a = 6;				//一个整型变量
	int int_size;			//整型变量的字节大小
	int_size = sizeof(a);	//取变量字节大小
	
	cout << "变量 a 所占的字节大小为：" << int_size << endl;
	return 0;
}

运行结果：

代码解析：

6、7 行声明两个变量 a 和 int_size
8 行根据上述格式获取变量 a 的字节大小
10 行输出变量 a 的字节大小。

本案例中sizeof(a)相当于获取整型变量的字节大小
可以自行测试其他数据类型的字节大小

demo23 求余下的物品数（%）

案例描述：

某公司准备在节假日给每位员工发相同数量的日用品。
已知日用品的件数一共有 10000 件，员工有 189 名，求平均分配后还剩多少件日用品。

实现过程：

首先需要定义 3 个整型变量
为总的物品数 num_goods、员工数目 num_staff、剩余物品数 remain_goods
现使用取余运算符计算机平均分配后还剩多少件日用品，

代码：

#include<iostream>
using namespace std;

int main() {
	int num_goods = 10000, num_staff = 189, remain_goods;	//对变量初始化
	remain_goods = num_goods % num_staff;					//计算剩余物品
	cout << "剩余的日用品的数量为：" << remain_goods << "件" << endl;
}

运行结果：

代码解析：

第 06～08 行用于声明 3 个变量
第 10 行表示计算所剩日用品件数的公式
第 11 行输出最后结果。

demo24 输入符合条件的整数（跳出循环）

案例描述：

本实例旨在模拟如何跳出循环，即在循环中如何打断它的下一步条件
现需要用户输入 1 个介于 1 和 50 的整数
如果不满足条件，重新输入；如果满足条件，则跳出循环。可以使用 break跳出循环，

实现过程：

定义整型变量 number 用于存储输入的整数值
使用 while(1)做无限循环，直到整数条件满足，则跳出循环。

代码：

#include<iostream>
using namespace std;

int main() {
	int num;
	while (1)
	{
		cout << "请输入一个1-50之间的数" << endl;
		cin >> num;
		if (num >= 1 && num <= 50)
		{
			cout << " 输入的数字符合条件 " << endl;
			break;
		}
	}
	return 0;
}

运行结果：

代码解析：

第 06 行定义整型变量 number，存储整数值
第 07～16 为无限循环，用于判断输入的整数值是否满足条件
如果输入的 number 值一直不满足第 11 行所示的条件，则一直提示用户输入整数，否则跳出循环(第 14 行)

demo25 命令响应（开关）

案例描述：

布尔变量一般用于判断使用状态，比如开关的状态、命令是否被响应等
本实例实现是否响应命令、是否继续响应、是否暂停响应、是否继续等待

实现过程：

 - 基于上述的描述需要有两个布尔变量，switcher 用于存储开关的当前状态、switcher_ex 用于存储开头前一时刻的状态。
 - 布尔变量只有两个值，即 true 和 false。在变量初始时，都赋值 false。 因为需要获取用户输入值，需要定义一个 char
 - 型变量 ch 用于存储该值。 该程序只响应 ch的 3 个类型值，即 Y、N、Q。

代码：

#include<iostream>
using namespace std;

int main() {
	char ch;
	bool switcher = false;		//开关状态
	bool switcher_ex = false;	//前一时刻的开关状态

	while (1)
	{
		cout << "是否要响应命令？是：输入 Y，不是：输入 N，退出：Q" << endl;
		cin >> ch;
		if (ch == 'Y')					//响应
		{
			switcher_ex = switcher;		//前一状态
			switcher = true;			//当前状态
			if(switcher_ex)
				cout << "继续响应命令!" << endl;
			else
				cout << "开始响应命令!" << endl;
		}
		else if (ch == 'N')				//不响应
		{
			switcher_ex = switcher;		//前一状态
			switcher = false;			//当前状态
			if (switcher_ex)
				cout << "暂停响应命令!" << endl;
			else
				cout << "继续等待响应命令!" << endl;
		}
		else if (ch == 'Q')				//退出
		{
				cout << "成功退出响应!" << endl;	
				break;
		}
		else
			cout << "输入错误，请输入正确的命令！！！" << endl;
	}

	return 0;
}

运行结果：

代码解析：

第 10～41 行为整个 while 循环，该循环为无限，只有满足退出条件才会跳出循环
如第 32～36 行所示。while 循环中嵌套 if…else if…else 判断结构。
如果输入 ch 值不是 Y、N、Q 之一，则提醒输入错误，如第 37～40 行所示。
本实例的重点是判断用户输入的是 Y 还是 N，实现判断的代码分别为第 14～22 行和第 23～31 行所示。
它们的结构都是先将当前的开关状态 switcher 赋给前一个状态变量 switcher_ex，然后根据 ch 值赋不同的值给当前状态变量 switcher，最后根据前一个状态变量 switcher_ex 判断是否继续执行前一个状态。

如果 while 循环为无限循环，即平常所说的死循环，那么内部必须有跳出循环的判断条件。

demo26 买水果小游戏（开关结构综合）

案例描述：

本实例实现一个简单的买水果小游戏，首先系统提示用户店里提供了哪些水果，单价为多少。
最后水果店根据用户的购买品种数量、所买品种各自的数量结算。

实现过程：

>本实例使用循环（while、for）和判断（switch）结构完成编码
>提示输入水果重量，然后取得重量，输入水果品种编号，取得品种编号对应的价格，计算应付的钱。
>在运行过程中，可能会输入不符合条件的数值，系统会给出相应的提示。

代码：

#include<iostream>
using namespace std;
double capital = 0.0;				//金额

double cal(int num, double quantity)
{
	switch (num)
	{
	case 0:
		return quantity * 1.50;
	case 1:
		return quantity * 1.70;
	case 2:
		return quantity * 4.60;
	case 3:
		return quantity * 0.90;
	case 4:
		return quantity * 2.50;
	case 5:
		return quantity * 3.70;
	case 6:
		return quantity * 7.60;
	case 7:
		return quantity * 3.90;
	default:
		return 0;
	}
}

int main() {
	//先将提示输出
	cout << "提示：本店提供 8 种水果，如下（左边为水果编号及名称，右边为其单价）" << endl;
	cout << "0 西瓜 1.50\t 1 木瓜 1.70\t 2 哈密瓜 4.60\t 3 苹果 0.9\n"
		 << "4 梨 2.50\t 5 柚子 3.70\t 6 弥猴桃 7.60\t 7 山楂 3.9" << endl;
	int num_choice = 0;		//几种选择
	//int* choice;
	//double* quantity_choice;
	while (1)
	{
		int Y_N;
		cout << "请输入您要购买的种类数量：";
		cin >> num_choice;
		
		if (num_choice == 0)		//不买东西
		{
			cout << "您确定只是看看吗？要不买点吧？继续请按 1，否则请按 0，直接退出"<<endl; 
			cin >> Y_N;
			if (Y_N == 0)
			{
				cout << "退出成功！" << endl;
				break;
			}
			else if (Y_N == 1)
				{}
			else
				cout << "不要捣乱，按规定输，亲" << endl;
		}
		else
		{
			cout << "种类编号分别为：";
			int* choice = new int[num_choice];
			double* quantity_choice = new double[num_choice];
			for (int i = 0; i < num_choice; i++)
				cin >> choice[i];				//种类编号
			cout << "请输入对应购买种类的重量:";
			for (int i = 0; i < num_choice; i++)
				cin >> quantity_choice[i];
	
			for (int j = 0; j < num_choice; j++) //计算金额
			{
				capital += cal(choice[j], quantity_choice[j]);
			}
	
			cout << "继续购物吗？继续请按 1，否则请按 0，开始结算" << endl;
			cin >> Y_N;
			if (Y_N == 0)
			{
				cout << "开始结算，请付" << capital << "元" << endl;
				break;
			}
			else if (Y_N == 1)
				{}
			else
				cout << "不要捣乱，按规定输，亲" << endl;
		}
		
	}
	delete[] choice;
	choice = NULL;
	delete[] quantity_choice;
	quantity_choice = NULL;
	return 0;
}

运行结果：

代码解析：

（1）第 04 行定义一个全局变量 capital 用于存储顾客所需付钱的总额。
（2）第 06～27 行为 cal 函数，作用是计算顾客购买水果的最后价格。输入参数为某种类型水果店的数量和重量，返回值为该种类型水果的总价。cal()函数使用 switch 结构实现。其中每个 case 中有 return 语句，所以不需要有 break 语句。
（3）第 29～90 行为入口函数 main()，第 34 行为顾客需要购买多少种水果（num_choice）。第 35～84 行是一个死循环，当满足条件，则跳出该循环。如果 num_choice 为 0 时，系统会提示顾客，如第 43 行所示。反之，系统需要顾客输入水果类型各自的编号，如第 61～62 行的 for循环所示。
（4）第 59 行的 choice 为水果编号，第 60 行的 quantity_choice 为所选水果各自的重量。因为事先不确定购买多少种水果，所以这两个变量需要用 new 方式申请内存。第 67～70 行的 for循环目的是实现金额的计算。当完成该次购物后，系统会提示是否继续购买，如第 72 行所示。

将金额 capital 设置为全局变量，目的是在多次购买时，下一次的金额不会覆盖上一次的金额值。

demo27 各类常量的使用示例（各种常量）

案例描述：

C++中常量的调用方法有很多种，如直接调用（1、1.2、true）、定义为常量以被调用（使用宏定义#define、常量定义关键字const）。

实现过程：

使用#define 宏定义浮点型变量 Pi 和字符串变量“1234”
利用 const 关键字定义 double 型常量 Pi1。其他常量的应用直接用 cout 语句输出

代码：

#include <iostream>
using namespace std;

#define Pi 3.1415
#define code "1234"

int main()
{
	cout << "常量例子 1：" << 1 << endl;		//各类常量的输出方式
	cout << "常量例子 2：" << true << endl;		//true为1，flase为0
	cout << "常量例子 3：" << "3456" << endl;
	cout << "常量例子 4：" << Pi << endl;		//输出 define 宏定义的常量
	cout << "常量例子 5：" << code << endl;
	const double Pi1 = 3.1415;
	cout << "常量例子 6：" << Pi1 << endl;		 //输出 const 定义的常量
	return 0;
}

运行结果：

代码解析：

任何基本类型的常量都可以直接调用
如 09～11 行，分别为整型、布尔型、字符串
12、13 行调用#define 定义的常量 Pi 和 code
15 行调用 const 定义的常量 Pi1。

使用#define 和 const 方式定义的常量都必须初始化，之后不可被再赋值。即不能再更改

demo28 用循环计算 9 的 9 次方（for）

案例描述：

对于数学中的幂次运算，需要与自身重复相乘许多次。
本实例实现计算 9 的 9 次方运算

实现过程：

利用 for 循环实现 9 的 9 次方计算
首先声明两个变量：a 和 result
a为循环次数，result 用于存储每次乘法之后的结果
可以使用*=运算符实现每次的计算结果为：result *= a；
因为每次相乘的乘法都是一样的，所以重复该计算公式 9 次即可，这里使用for循环

代码：

#include<iostream>
using namespace std;
int main() {
	int a = 9;
	int result = 1;						//结果
	for (int i = 0; i < 9; i++)			//循环
	{
		result *= a;
	}
	cout << "9的9次方等于：" << result << endl;	//输出
	return 0;
}

运行结果：

代码解析：

此处用 for 循环实现幂次运算，第 10 行给出了程序的核心公式。只要将此公式的运算重复9 次，即可完成计算
第 08 行按照 for 循环的书写格式给出起始条件（int i=1）、终止条件（i<=9）、进入下一步条件（i++）。

在 C++的 API 函数中有 pow()函数可以完成上述计算，需要包含头文件math.h。

demo29 寻找出口小游戏（do while）

案例描述：

走迷宫这款小游戏也被称为寻找出口小游戏，本实例模拟该游戏实现对循环结构 do…while的练习
在判断当前元素是否为出口时，使用 switch 结构完成

实现过程：

因为涉及行列循环，所以本实例使用两个 do…while 结构实现，即一个 do…while 结构中嵌套另一个 do…while，各自进行的下一步条件为行列加 1。
首先定义一个二维数组变量 migong，用于存放迷宫数据
当元素为 0 时，可以通过；如果是 1，不可通过；如果是 2，则为迷宫出口。

代码：

#include <iostream>
using namespace std;

int main()
{
	int migong[5][5] = { {0,0,1,1,1},{1,0,0,1,1},{1,1,0,1,1},{1,1,0,0,1},{1,1,1,0,2} };//迷宫
	int row, column; //行列
	int path_row[25];//通行路径的行
	int path_column[25]; //通行路径的列
	for (int i = 0; i < 25; i++) //初始化
		path_row[i] = path_column[i] = 0;
		
	row = 0;
	column = 0;
	int count = 0; //次数
	do //按行循环，先处理，后判断
	{
		column = 0;
		do //按列循环，先处理，后判断
		{
			switch (migong[row][column])
			{
			case 0: //可以通行
				path_row[count] = row;
				path_column[count] = column;
				cout << "加油，快要找到出口了" << endl;
				count++;
				break;
			case 1: //不可通行
				cout << "不可通行" << endl;
				break;
			case 2: //到达出口
				path_row[count] = row;
				path_column[count] = column;
				cout << "到达出口" << endl;
				count++;
				break;
				}
			column += 1;
		}while (column < 5);
		
		row += 1;
		}while (row < 5);
		
	cout << "到达出口的路径为:" << endl;
	for (int j = 0; j < count; j++) //输出出口路径
	{
	cout << "(" << path_row[j] << "," << path_column[j] << ")->";
	}
	cout << endl;
	
	return 0;
}

运行结果：

代码解析：

06 行可知，该迷宫的出口位于第 4 行第 4 列
08、09 行用于存放到达出口的路径各行列值
17～41 行为按行循环的 do…while 结构
20～39 行为按列循环的 do…while 结构
47～50 行输出路径链。

19 行将列值赋为 0，该句必须有！！！必须回到数组列数的第 0 列，否则会越界。
就是一行遍历完成之后，再从下一行的第一列开始遍历

demo30 一个简单的数据统计系统（综合）

案例描述：

本实例实现一个简单的数据统计系统，即在一串输入的字符中找到目标字符出现过多少次，可被分为两个功能：搜索和统计。

实现过程：

定义一个字符串 str，用于获取输入的源数据
count_0 统计数据中出现 0 的次数，

代码：

#include <iostream>
using namespace std;

int main()
{
	cout << "请输入一串数字，不能有空格等非数字字符" << endl;
	string str;
	int count_0 = 0;							//0 出现的次数
	cin >> str;									//输入
	cout << "数字 0 出现的次数为:";
	for (int i = 0; i < str.length(); i++)		//判断
	{
		if (str[i] == '0')						//如果等于 0 
			count_0++;
	}
	
	cout << count_0 << endl;
	
	return 0;
}

运行结果：

代码解析：

本实例的核心内容是第 14、15 行，先判断当前元素是否为 0。
如果为 0，count_0 加 1，否则什么都不做，直到搜索到达数据的末位（结束搜索）。

length()函数是string的成员，它是用来获取字符串长度的

demo31 投骰子游戏（随机）

案例描述：

在玩牌或麻将等游戏时总少不了投骰子，本实例模拟投骰子游戏
投骰子的结果可由概率统计得到
本实例演示掷一枚 6 点骰子（即一个骰子有 6 面，包括 1、2、3、4、5、6 这 6 个点）得到其结果点数
由概率论可知，出现其中一个点数的概率是 1/6，可被看作是随机现象。

实现过程：

实现本实例需要两个函数 srand()和 rand()，用于模拟当前时刻得到位于 1 到 6 之间的整数
函数 srand()和 rand()一起使用可以产生伪随机数
伪随机数其实是有周期的。真正的随机数是使用物理现象产生的：比如掷钱币、骰子、转轮、使用电子元件的噪音、核裂变等等，这样的随机数发生器叫做物理性随机数发生器，它们的缺点是技术要求比较高。（这里为了学习语言，所以使用的是伪随机数）
本实例循环 10000 次，统计结果并打印每个点数出现的概率

代码：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
using namespace std;

int main()
{
	int i, result;
	srand((int)time(0)); //利用系统时间产生随机序列的种子值
	int count[6] = { 0 };//1～6 的统计个数
	for (i = 0; i < 10000; i++)
	{
		result = 1 + (int)(6.0 * rand() / (RAND_MAX + 1.0));//设置出现 1～6 之间的整数
		switch (result)
		{
		case 1:
			count[0]++;
			break;
		case 2:
			count[1]++;
			break;
		case 3:
			count[2]++;
			break;
		case 4:
			count[3]++;
			break;
		case 5:
			count[4]++;
			break;
		case 6:
			count[5]++;
			break;
		}
	}
		
	cout << "1～6 点的出现概率依次为：";
	for (int k = 0; k < 6; k++) //打印每点出现的概率
	cout << count[k] / 10000.0 << ",";
	
	cout << endl;
	
	return 0;
}

运行结果：

代码解析：

9 行定义变量 i（表示循环次数）、result（当前产生的随机数）
10 行利用系统时间产生随机序列的种子值，这样可以保证每次运行程序时产生的随机值都不同
11 行定义的数组count用于计数1～6产生的次数，由第15～35行的switch结构
12～36行循环10000次，获取 10000 个投骰子后结果
14 行利用 rand()函数产生介于 1～6 之间的随机数
39～40 行输出每点出现的概率，实验证明结果接近于 1/6。

使用函数 srand()、rand()、time()必须包含第 01～03 行的头文件。