开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> 【比特鹏哥C语言_4.数组】 -> 正文阅读

[C++知识库]【比特鹏哥C语言_4.数组】

本章重点

一维数组的创建和初始化
一维数组的使用
一维数组在内存中的存储
二维数组的创建和初始化
二维数组的使用
二维数组在内存中的存储
数组作为函数参数
数组的应用实例1：三子棋
数组的应用实例2：扫雷游戏

一、一维数组的创建和初始化

1.数组的创建

数组是一组相同类型元素的集合。数组的创建方式：

type_t arr_name [const_n]
//type_t 是指数组的元素类型
//const_n 是一个常量表达式（不能用变量），用来指定数组的大小
//（注意：数组的大小是指元素的个数，元素的个数要比下标大1）

注：C99语法支持变长数组（即数组的大小是变量），但VS2022不支持变长数组

2.数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些初始值

int arr1[5]={1,2,3,4,5};//完全初始化
int arr2[5]={1};//不完全初始化
//下面两种初始化等价
int arr3[ ]={1,2,3};
int arr3[3]={1,2,3};

//字符数组初始化
char ch1[5]={'b','i','t'};//其实里面存放的是b i t \0 \0
char ch2[ ]={'b','i','t'};//里面存放的是b i t 

char ch3[5]="bit";//其实里面存放的是b i t \0 \0
char ch4[ ]="bit";//其实里面存放的是b i t \0

数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定。但是对于上面的单引号和双引号要区分内存中如何分配。

char ch2[ ]={'b','i','t'};//里面存放的是b i t 
char ch4[ ]="bit";//其实里面存放的是b i t \0 
printf("%s\n",ch2);
printf("%s\n",ch4);
//输出结果：
//bit乱码乱码乱码
//bit
//因为输出是遇到\0才会停止的，而数组ch2没有\0，所以会有乱码输出

二、一维数组的使用

对于数组的使用我们之前介绍了一个操作符：[ ]，下标引用操作符。它其实就数组访问的操作符。我们来看代码：

#include <stdio.h>
int main()
{
	int arr[10]={0};//注意这里是定义了10个元素
	arr[4]=5;//[ ] 是下标引用操作符。
	//注意，这里的[4]是第5个元素，下标是4，而初始化的[10]是10个元素
}

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };//数组的不完全初始化
	//计算元素个数
	int sz = sizeof(arr) / sizeof(arr[0]);
	//对数组内容赋值，数组是使用下标来访问的，下标从0开始。所以：
	int i = 0;//做下标
	for (i = 0;i < 10;i++)
	{
		arr[i] = i;
	}
	//输出数组的内容
	for (i = 0;i < 10;i++)
	{
		printf("%d ", arr[i]);
	}
		return 0;
}

总结：

数组是使用下标来访问的，下标是从0开始。
数组的大小可以通过计算得到。

int arr[10] = { 0 };
int sz = sizeof(arr) / sizeof(arr[0]);

三、一维数组在内存中的存储

//%p - 是按地址的格式打印 - 十六进制的打印
//%x - 打印十六进制数
int main()
{
	//printf("%x\n", 284);//输出结果：11c
	//printf("%p\n", 284);//输出结果：0000011C（32位平台有8位，64位平台有16位）
	//解释为什么是8位：一个字节8比特位，也就是8个二进制位。四个二进制最大表示为15，就是一个16进制数，所以8位可以表示成2个16进制的数
	// 所以这么理解：一个字节表示8个二进制位，表示2个16进制位
	int arr[10] = { 0 };
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		printf("%p\n", &arr[i]);
	}
	return 0;
}

输出结果：
在这里插入图片描述

总结：

一维数组在内存中是连续存放的！
随着数组下标的增长，地址是由低到高变化的！
数组名是数组首元素的地址

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10};
	int* p = arr;//数组名是数组首元素的地址
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		printf("%d ", *p);//一维数组在内存中是**连续存放**的
		p++;//所以每++一次，就能得到下一个元素的地址
	}
	return 0;
}
//输出结果：1 2 3 4 5 6 7 8 9 10

四、二维数组的创建和初始化

1.二维数组的创建

//数组创建
int arr[3] [4];//3行4列，int类型
char arr[3] [4];//3行4列，char类型
double arr[2] [4];//2行4列，double类型

2.二维数组的初始化

//数组初始化-创建的同时给赋值
int arr[3] [4] = {1,2,3,4,5,6,7,8,9,10,11,12};
//内存中的存放情况是：
//1列 2列 3列 4列
//1行  1   2   3   4
//2行  5   6   7   8
//3行  9   10  11  12
int arr[3] [4] = {1,2,3,4,5,6,7};//不完全初始化，后面补0（char类型补\0）
//内存中的存放情况是：
//1列 2列 3列 4列
//1行  1   2   3   4
//2行  5   6   7   0
//3行  0   0   0   0
int arr[3] [4] = { {1,2}, {3,4}, {4,5} };
//内存中的存放情况是：
//1列 2列 3列 4列
//1行  1   2   0   0
//2行  3   4   0   0
//3行  4   5   0   0
int arr[ ] [4]= { {1,2}, {3,4}, {4,5} };//二维数组行可以省略，但是列不能省略
//内存中的存放情况是：
//0列 1列 2列 3列
//0行  1   2   0   0
//1行  3   4   0   0
//2行  4   5   0   0

3. 总结

arr[3] [4],第一个[ ] 是行，第二个是列，行可以省略，列不可以省略
不完全初始化，后面补0
在创建的时候，[ ]里面的数字是规定几行几列，写几就是几；在使用的时候，是从0开始的

五、二维数组的使用

使用的时候，行号和列号都是从0开始的

int main()
{
	int arr[3][4] = { {1,2}, {3,4}, {4,5} };
	int i = 0, j = 0;
	for (i = 0;i < 3;i++)
	{
		for (j = 0;j < 4;j++)
		{
			printf("%d ",arr[i][j]);
		}
		printf("\n");
	}
}

在这里插入图片描述

六、二维数组在内存中的存储

int main()
{
	int arr[3][4] = { {1,2}, {3,4}, {4,5} };
	int i = 0, j = 0;
	for (i = 0;i < 3;i++)
	{
		for (j = 0;j < 4;j++)
		{
			printf("&arr[%d][%d] = %p\n",i,j,&arr[i][j]);
		}
	}
}

在这里插入图片描述
会发现，每个相邻的元素，都是差四个字节，因为整形变量在内存中的存储是四个字节

总结

二维数组在内存中也是连续存放的！一行内部是连续的，行与行之间也是连续的！
也就是说，二位数组在内存中也是一维的！
在这里插入图片描述

知道二维数组也是连续存放的好处：我只要知道首元素地址，就知道后面元素的地址！

int main()
{
	int arr[3][4] = { {1,2}, {3,4}, {4,5} };
	int i = 0, j = 0;
	int* p = &arr[0][0];//将首元素的地址放在p中
	for (i = 0;i <12;i++)
	{
		printf("%d ", *p);
		p++;
	}
}

在这里插入图片描述

七、数组作为函数参数

在写代码的时候，会将数组作为参数传给函数，比如：我要实现一个冒泡排序（这里讲算法思想）函数将一个整型数组排序。
冒泡排序的思想：
两两相邻的元素进行比较，并且可能的话需要交换！

在这里插入图片描述

//冒泡排序函数的错误设计：
//错误原因：当数组传参的时候，实际上只是把数组的首元素的地址传递过去了。
//所以即使在函数参数部分写成数组的形式：int arr[]表示的依然是一个指针：int* arr
void bubble_sort(int arr[])//形参arr本质是指针
{
	//计算数组元素个数
	int sz = sizeof(arr) / sizof(arr[0]);//err：arr本质是int类型指针，大小为4，arr[0]是整型，也是4，所以sz为1
	//确定趟数
	int i = 0;
	for (i = 0;i < sz - 1;i++)
	{
		//一趟冒泡排序的过程
		int j = 0;//确定对数
		for (j = 0;j <sz-1-i ;j++)
		{
			if (arr[j] > arr[j + 1])
			{
				//交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	//排序为升序 - 用冒泡排序
	bubble_sort(arr);//数组传参的时候，传递的其实是数组首元素的地址
	return 0;
}

//冒泡正确设计
#include <stdlib.h>
void bubble_sort(int arr[],int sz)//形参arr本质是指针
{
	//确定趟数
	int i = 0;
	for (i = 0;i < sz - 1;i++)
	{
		//一趟冒泡排序的过程
		int j = 0;//确定对数
		for (j = 0;j < sz - 1 - i;j++)
		{
			if (arr[j] > arr[j + 1])
			{
				//交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	//排序为升序 - 用冒泡排序
	//计算数组元素个数
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr,sz);//数组传参的时候，传递的其实是数组首元素的地址
	return 0;
}

数组名是什么？

数组名是数组首元素的地址，但是有两个例外：

sizeof(数组名) - 数组名表示整个数组 - 计算的是整个数组的大小（单位是字节）
&数组名 - 数组名表示整个数组 - 取出的是整个数组的地址
除这两个例外，数组名是数组首元素的地址。

八、数组的应用实例1：三子棋

将三子棋分为三个模块进行制作
在这里插入图片描述

模块一：测试游戏的逻辑：test.c

注意：写完一个小模块就要赶紧测试，不要，整个工程都写完了才去测试！
test.c：测试游戏逻辑

#include<stdio.h>
void menu()
{
	printf("*****************************\n");
	printf("********   三 子 棋  ********\n");
	printf("********   1. play   ********\n");
	printf("********   0. exit   ********\n");
	printf("*****************************\n");
}
int main()
{
	int input = 0;
	do//我们用do while循环做菜单，为了实现至少玩一次，并可选择是否多玩几次
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)//根据input的值判断是否开始游戏
		{
		case 1:
			printf("三子棋游戏\n");
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，重新选择\n");
			break;//当选择错误时，会跳出Switch，但不会跳出循环
			//而且input为真，所以会再次进入循环
		}
	} while (input);//当input为假时跳出循环
	return 0;
}

测试完后，发现可以实现我们想要的逻辑，那么就可以开始封装函数，来实现游戏的功能

#define _CRT_SECURE_NO_WARNINGS 1
#include "game.h"//在这个解决方案内的.h文件，则用""
void menu()
{
	printf("*****************************\n");
	printf("********   三 子 棋  ********\n");
	printf("********   1. play   ********\n");
	printf("********   0. exit   ********\n");
	printf("*****************************\n");
}
void game()
{
	//存储数据 - 二维数组
	char board[ROW][COL];//因为要用*和#做棋子，所以用char
	//初始化棋盘 - 初始化空格（因为棋盘的内容是用数组存放，所以不能是空的没有内容，只能存放空格)
	InitBoard(board, ROW, COL);//因为要初始化棋盘，所以要包含board这个二维数组；
	//又因为这个函数不知道这个二维数组有几行几列，所以要将ROW和COL传给这个函数

	//打印一下棋盘 - 本质是打印数组的内容
	DisplayBoard(board, ROW, COL);

	char ret = 0;//接收游戏状态
	while (1)
	{
		//玩家下棋
		PlayerMove(board, ROW, COL);
		DisplayBoard(board, ROW, COL);
		//判断玩家是否赢
		//游戏进行过程有四种：
		//1.玩家赢 - 返回*
		//2.电脑赢 - 返回#
		//3.平局（棋盘下满但没人赢）- 返回Q
		//4.游戏继续 - 返回C
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;//不为C，游戏结束
		//电脑下棋
		ComputerMove(board, ROW, COL);
		DisplayBoard(board, ROW, COL);
		//判断电脑是否赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;//不为C，游戏结束
	}
	if (ret == '*')
	{
		printf("玩家赢了\n");
	}
	else if(ret=='#')
		printf("电脑赢了\n");
	else
		printf("平局\n");
	DisplayBoard(board, ROW, COL);
}
int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));//每打开一次程序srand函数只需要执行一次，所以放在主函数中
	do//我们用do while循环做菜单，为了实现至少玩一次，并可选择是否多玩几次
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)//根据input的值判断是否开始游戏
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，重新选择\n");
			break;//当选择错误时，会跳出Switch，但不会跳出循环
			//而且input为真，所以会再次进入循环
		}
	} while (input);//当input为假时跳出循环
	return 0;
}

模块二：函数的声明、符号的声明、头文件的包含：game.h

#pragma once

//0.头文件的包含
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//1.符号的定义

//1.1定义棋盘的大小
//意义：只要将这里的3改成其他数，所有用到的地方都会更改
#define ROW 3//将行数定义为ROW
#define COL 3//将列数定义为COL

//2.函数的声明

//初始化棋盘的函数
void InitBoard(char board[ROW][COL], int row, int col);//row和col来接收真实传递给这个函数的行和列

//打印棋盘的函数
void DisplayBoard(char board[ROW][COL], int row, int col);

//玩家下棋
void PlayerMove(char board[ROW][COL], int row,int col);
//电脑下棋
void ComputerMove(char board[ROW][COL], int row, int col);
//判断玩家是否赢
char IsWin(char board[ROW][COL], int row, int col);

模块三：游戏相关函数的实现

#define _CRT_SECURE_NO_WARNINGS 1
#include "game.h"
//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0;i < row;i++)
	{
		for (j = 0;j < col;j++)
		{
			board[i][j] = ' ';//第i行，第j列填空格
		}
	}
}
//打印棋盘缺陷版
//此代码不够好，只适用于三行三列的棋盘
//void DisplayBoard(char board[ROW][COL], int row, int col)
//{ 
//	int i = 0;
//	for (i = 0;i < row;i++)
//	{
//		printf(" % c | % c | % c \n", board[i][0], board[i][1], board[i][2]);//这里每一行有几个元素是写死了，这里只有三个
//		if (i < row - 1)
//		{
//			printf("---|---|---\n");
//		}
//	}
//}
//打印棋盘
void DisplayBoard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	//int j = 0;不要写在这里
	for (i = 0;i < row;i++)
	{
		//用二维数组的列来管理每行的元素
		int j = 0;
		for (j = 0;j < col;j++)
		{
			printf(" %c ", board[i][j]);
			if (j < col - 1)
				printf("|");
		}
		printf("\n");
		if (i < row - 1)//用if的原因是，分割线要比填空处少一行
		{
			int j = 0;
			for (j = 0;j < col;j++)
			{
				printf("---");
				if (j < col - 1)
					printf("|");
			}
			printf("\n");
		}
	}
}
//玩家下棋
void PlayerMove(char board[ROW][COL], int row, int col)
{
	int x = 0, y = 0;
	printf("玩家走:->\n");
	while (1)//如果是非法输入，就要重新判断，所以用循环
	{
		printf("请输入下棋的坐标:->");
		scanf("%d %d", &x, &y);
		//判断坐标合法性
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			//下棋
			//判断坐标是否被占用
			if (board[x - 1][y - 1] == ' ')
			{
				board[x - 1][y - 1] = '*';//没被占用就可以下一个*
				break;//下一个棋就跳出while循环，因为每人只能下一步
			}
			else
			{
				printf("坐标被占用，请重新输入\n");
			}
		}
		else
		{
			printf("坐标非法，请重新输入\n");
		}
	}
}
//电脑下棋
void ComputerMove(char board[ROW][COL], int row, int col)
{
	printf("电脑走:>\n");
	while (1)
	{
		int x = rand() % row;//得到的随机数模上行数，就一定能出现正确范围内的数
		int y = rand() % col;
		//判断占用
		if (board[x][y] == ' ')
		{
			board[x][y] = '#';
			break;
		}
	}
}
//判断游戏进行状态
//游戏进行过程有四种：
//1.玩家赢 - 返回*
//2.电脑赢 - 返回#
//3.平局（棋盘下满但没人赢）- 返回Q
//4.游戏继续 - 返回C
int IsFull(char board[ROW][COL], int row, int col)
{
	int i = 0, j = 0;
	for (i = 0;i < row;i++)
	{
		for (j = 0;j < col;j++)
		{
			if (board[i][j] == ' ')
			{
				return 0;//棋盘没满
			}
		}
	}
	return 1;//满了返回1
}
char IsWin(char board[ROW][COL], int row, int col)
{
	int i = 0;
	//判断三行
	for (i = 0;i < row;i++)
	{
		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ')
		{
			return board[i][1];
		}
	}
	//判断三列
	for (i = 0;i < col;i++)
	{
		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ')
		{
			return board[0][i];
		}
	}
	//对角线
	if (board[0][0] == board[1][1] && board[1][1] == board[2][2]  && board[2][2] != ' ')
	{
		return board[1][1];
	}
	if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
	{
		return board[1][1];
	}
	//判断平局
	//如果棋盘满返回1，不满返回0
	int ret=IsFull(board, row, col);
	if (ret == 1)
	{
		return 'Q';
	}
	//继续游戏
	return 'C';
}

九、数组的应用实例2：扫雷游戏

在这里插入图片描述

模块一：扫雷游戏的测试：test.c

测试菜单代码是否正确

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

void menu()
{
	printf("********************\n");
	printf("****    扫雷    ****\n");
	printf("****   1.play   ****\n");
	printf("****   0.exit   ****\n");
	printf("********************\n");
}
int main()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d",&input );
		switch (input)
		{
		case 1:
			printf("扫雷\n");
			break;
		case0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，重新选择\n");
			break;
		}
	} while (input);
	return 0;
}

测试正确后，开始写函数（注意：每实现一个功能，就进行一次测试）
在这里插入图片描述

为了两个数组的元素能够对应上，两个数组都应是11*11的
初始化棋盘的时候：

文件test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "game.h"
void menu()
{
	printf("********************\n");
	printf("****    扫雷    ****\n");
	printf("****   1.play   ****\n");
	printf("****   0.exit   ****\n");
	printf("********************\n");
}
void game()
{
	//如果要实现一个9*9的棋盘，就要做成11*11的数组，因为要考虑边缘溢出的情况
	char mine[ROWS][COLS] = { 0 };//存放布置好的雷的信息
	char show[ROWS][COLS] = { 0 };//存放排查出的雷的信息
	//初始化棋盘
	InitBoard(mine, ROWS, COLS, '0');//怎么保证用这一个函数同时满足两个棋盘需要填充的字符呢？
	InitBoard(show, ROWS, COLS, '*');//答：再设一个形参set，然后将需要的字符传给这个函数
	//打印棋盘 - 只需要打印真正的棋盘，即9*9
	//DisPlayBoard(mine, ROW, COL);//不打印，仅测试
	DisPlayBoard(show, ROW, COL);
	//布置雷
	SetMine(mine, ROW, COL);
	//DisPlayBoard(mine, ROW, COL);//看一下雷有没有设对（仅测试时用）
	//排查雷
	FindMine(mine, show, ROW, COL);
}
int main()
{
	int input = 0;
	srand((unsigned)time(NULL));
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d",&input );
		switch (input)
		{
		case 1:
			game();//扫雷游戏的实现
			break;
		case0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，重新选择\n");
			break;
		}
	} while (input);
	return 0;
}
//可以优化的
//1.如果不是雷，周围也没有雷 - 展开一片 - 用递归
//2.标记雷

模块二：函数的声明

文件game.h

#pragma once

//0.头文件的包含
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//1.符号的定义

//1.1实际所用棋盘的大小
#define ROW 9
#define COL 9
//1.2需要更大的棋盘存放溢出的信息
#define ROWS ROW+2
#define COLS COL+2
//1.3雷的数目
#define EASY_COUNT 10
//2.函数的声明

//初始化棋盘的函数
void InitBoard(char board[ROWS][COLS], int rows, int cols,char set);
//打印棋盘
void DisPlayBoard(char board[ROWS][COLS], int row, int col);
//布置雷
void SetMine(char mine[ROWS][COLS], int row, int col);
//排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

模块三：游戏相关函数的实现

文件game.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "game.h"
//初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
{
	int i = 0, j = 0;
	for (i = 0;i < rows;i++)
	{
		for (j = 0;j < cols;j++)
		{
			board[i][j] = set;
		}
	}
}
//打印棋盘
void DisPlayBoard(char board[ROWS][COLS], int row, int col)
{
	printf("------扫雷游戏---------\n");
	int i = 1, j = 1;//因为只打印11*11中间的9*9，所以下标是从1开始的,到9结束
	//打印行号
	printf("  ");
	for (i = 1;i <= col;i++)
	{
		printf("%d ", i);
	}
	printf("\n");
	for (i = 1;i <= row;i++)//所以注意这里是<=
	{
		printf("%d ", i);//打印列号
		for (j = 1;j <= col;j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
	printf("------扫雷游戏---------\n");
}
//布置雷
void SetMine(char mine[ROWS][COLS], int row, int col)
{
	//布置10个雷
	int count = EASY_COUNT;
	while (count)
	{
		//生产随机的下标
		int x = rand() % row + 1;//注意我们是在11*11中间的9*9，所以下标是从1到9
		int y = rand() % row + 1;
		//约定：没雷是0，有雷是1
		if (mine[x][y] == '0')//如果这里没放雷
		{
			mine[x][y] = '1';//就放一个雷
			count--;
		}
	}
}
//统计雷
static int get_mine_count(char mine[ROWS][COLS], int x, int y)//因为这个函数只是为了服务排查雷函数，所以用static让本函数只能在这个.c文件中使用
{
	//如果我们要统计x,y处的雷的个数，我们只需要知道：
	//(x-1,y-1)  (x-1,y)  (x-1,y+1)
	//( x ,y-1)  ( x ,y)  ( x ,y+1)
	//(x+1,y-1)  (x+1,y)  (x+1,y+1)
	//处有几个雷
	return  mine[x - 1][y - 1] +
		mine[x - 1][y] +
		mine[x - 1][y + 1] +
		mine[x][y - 1] +
		mine[x][y + 1] +
		mine[x + 1][y - 1] +
		mine[x + 1][y] +
		mine[x + 1][y + 1] - 8 * '0';//减去8个字符0是为了将字符数改成数字
}
//排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	//1.输入排查的坐标
	//2.检查坐标处是不是雷
	(1)是雷 - 炸死 - 游戏结束
	(2)不是雷 - 统计坐标周围有几个雷 - 存储排查雷的信息到show数组，游戏继续
	int x = 0, y = 0;
	int win = 0;
	while (win<row*col-EASY_COUNT)//当win<row*col-EASY_COUNT时说明还没赢
	{
		printf("请输入要排查的坐标:>");
		scanf("%d%d", &x, &y);//x的取值范围是1-9 y的取值范围也是1-9

		//判断坐标的合法性
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (mine[x][y] == '1')//是雷的话
			{
				printf("很遗憾，你被炸死了\n");
				DisPlayBoard(mine, row, col);
				break;
			}
			else
			{
				//不是雷的话，统计x,y坐标周围有几个雷
				int count = get_mine_count(mine, x, y);//用一个函数去统计雷，将雷的个数传递给count
				show[x][y] = count+'0';//由ASII表得知数字0和字符0之间相差48,用数字0~9+字符0就得到了字符0~9
				//显示出排查的信息
				DisPlayBoard(show, row, col);
				win++;
			}
		}
		else
		{
			printf("坐标不合法，请重新输入\n");
		}
	}
	if (win == row * col - EASY_COUNT)
	{
		printf("恭喜你，排雷成功\n");
		DisPlayBoard(mine, row, col);
	}
}