匠心制作-初识C语言：第4节-数组

努力学习的J1an-JIan

已于 2024-05-06 22:53:02 修改

阅读量696

点赞数 19

分类专栏： C语言文章标签： c语言开发语言

于 2024-05-06 22:52:18 首次发布

本文链接：https://blog.csdn.net/weixin_49172485/article/details/138511228

版权

C语言专栏收录该内容

4 篇文章 0 订阅

订阅专栏

详解代码：Gatsby_Daisy/c语言 - 码云 - 开源中国 (gitee.com)

-想看代码范围请看最下面的 C语言-PDF与test详情.md

-该章节代码：test_3_7: 一维数组的学习 -test_3_9_game2:扫雷游戏

4-数组

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

1. 一维数组的创建和初始化

1.1数组的创建

数组是一组相同类型元素的集合。

数组的创建方式：

type_t   arr_name   [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小

数组创建的实例：

//代码1
int arr1[10];

//代码2
char arr2[10];
float arr3[1];
double arr4[20];

//代码3
int N = 10;
int arr5[N];//数组是否可以正常创建？

**注：**数组创建，在C99标准之前，[]中要给一个常量才可以，不能使用变量。在C99标准支持了变长数组的概念。

1.2 数组的初始化

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

看代码：

int arr1[10] = {1,2,3,4,5,6,7,8,9,10};//完全初始化
int arr2[10] = { 1,2,3,4,5 };//不完全初始化
int arr3[] = { 1,2,3,4,5 };
int arr4[5] = { 1,2,3,4,5 };
char arr5[] = {'a','b','c'};
char arr6[] = "abcdef";

数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定。

但是对于下面的代码要区分，内存中如何分配。

char arr1[] = "abc";
char arr2[3] = {'a','b','c'};

1.3 一维数组的使用

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

我们来看代码：

#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++)//这里写10，好不好？
    {
        arr[i] = i;
    } 
    //输出数组的内容
    for(i=0; i<10; ++i)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

总结：

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

int arr1[5]= {0};
int sz = sizeof(arr1)/sizeof(arr1[0]);

1.4 一维数组在内存中的存储

接下来我们探讨数组在内存中是如何存储的！

看代码：

#include <stdio.h>
int main()
{
    int arr1[10] = {0};
    int i = 0;
    int sz = sizeof(arr1)/sizeof(arr1[0]);

    for(i=0; i<sz; ++i)
    {
        printf("&arr1[%d] = %p\n", i, &arr1[i]);
    }
    return 0;
}

结果如下：

在这里插入图片描述

仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。

由此可以得出结论：数组在内存中是连续存放的。 在这里插入图片描述

2. 二维数组的创建和初始化

2.1 创建二维数组

//创建二维数组
int arr[3][4];
char ch[3][10];

2.2 二维数组的初始化

//初始化 - 创建的同时给赋值
int arr[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
int arr[3][4] = { 1,2,3,4,5,6,7 };//不完全初始化 - 后面补0
int arr[3][4] = { {1,2}, {3,4} ,{4,5} };
int arr[][4] = {{2,3},{4,5}};//二维数组如果有初始化，行可以省略，列不能省略

2.3 二维数组的使用

二维数组的使用也是通过下标的方式。

看代码：

#include <stdio.h>
int main()
{
    int arr[3][4] = {0};
    int i = 0;
    for(i=0; i<3; i++)
    {
        int j = 0;
        for(j=0; j<4; j++)
        {
            arr[i][j] = i*4+j;
        }
    }
    for(i=0; i<3; i++)
    {
        int j = 0;
        for(j=0; j<4; j++)
        {
            printf("%d ", arr[i][j]);
        }
    }
    return 0;
}

2.4 二维数组在内存中的存储

像一维数组一样，这里我们尝试打印二维数组的每个元素

#include <stdio.h>
int main()
{
    int arr[3][4];
    int i = 0;
    for(i=0; i<3; i++)
    {
        int j = 0;
        for(j=0; j<4; j++)
        {
            printf("&arr[%d][%d] = %p\n", i, j,&arr[i][j]);
        }
    }
    return 0;
}

输出的结果：

在这里插入图片描述

通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。

在这里插入图片描述

3. 数组越界

数组的下标是有范围限制的。

数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。

所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。

C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的， 所以程序员写代码时，最好自己做越界的检查。

数组越界情况如下：

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int i = 0;
    for(i=0; i<=10; i++)
    {
        printf("%d\n", arr[i]);//当i等于10的时候，越界访问了
    }
    return 0;
}

**注：**二维数组的行和列也可能存在越界

4. 数组作为函数参数

往往我们在写代码的时候，会将数组作为参数传个函数。

比如：我要实现一个冒泡排序函数（这里要讲算法思想）将一个整形数组排序。

4.1 冒泡排序的错误示范

bubble_sort(int arr[])
{
	//int arr[] = { 9,8,7,6,5,4,3,2,1,0 }; 先拿9跟相邻相比 若9 大于旁边的就交换
	//              8,9,7,6,5,4,3,2,1,0   一直比到最右或者出现有比9大的数  这为一趟
	//10个数字  - 9趟
	// 1;
	// 10个数字比较   9对比较
	// 2:
	// 9个数字比较    8对比较
	
	//先求出元素个数，才直到要走几趟
	int sz = sizeof(arr) / sizeof(arr[0]);//这里对吗？
	//确定趟数
	int i = 0;
	for (i = 0; i <sz-1; i++)  //
	{
		//一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz-1-i; j++) 
		//假设一趟，i就是0,j<9,比较9次；若i=1是第二趟，则j要<8，开始比较8次
		{
			if (arr[j] > arr[j + 1])
			{
				//交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}

}
int main()
{
	//排序为升序
	//int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };

	bubble_sort(arr);
	//此时代码有问题，能编译，但不出结果，按F10看看为什么
	//发现bubble_sort 里的sz求出来是1，为什？
	//其实上次就出现过这样的例子
	//bubble_sort(arr); 此时数组arr传参数，传的是数组的首地址，所以说传的还是地址，32位计算机地址是4字节 
	return 0;
}

方法中，出现了问题，调试找一下问题的所在，然后可以看到bubble_sort函数内部的sz是1。这是为何？

难道数组作为函数参数的时候，不是把整个数组的传递过去？

接下来，我们来了解：数组名

4.2 数组名

int main()
{
	int arr[10] = { 0 };
	printf("%p\n", &arr);//1  &arr取出的是数组的地址
	printf("%p\n", &arr[0]);//与上面结果一样，取出数组首元素（第一个元素）地址
	printf("%p\n", &arr+1);//取出数组的地址，然后加1，就是跳过这个数组


	printf("%p\n", arr);//2
	printf("%p\n", arr+1);//2 首元素下一给地址，就是第二个元素地址

	 //printf("%p\n", &arr[0]);//3  取出数组首元素（第一个元素）地址

	 //int sz = sizeof(arr);//数组名表示整个数组
	 //printf("%d\n", sz);//40   数组个数10 × 4 = 40

	//printf("%p\n", &arr[0]);
	//printf("%p\n", arr);//数组名是首元素的地址
	return 0;
}

数组名是什么？

数组名是数组首元素的地址

但是有2个例外

sizeof(数组名) - 数组名表示整个数组 - 计算的是整个数组的大小,单位是字节
&数组名 - 数组名表示整个数组 - 取出的是整个数组的地址

4.3 冒泡排序的正确方法

分析：

当数组传参的时候，实际上只是把数组的首元素的地址传递过去了。

所以即使在函数参数部分写成数组的形式：int arr[]表示的依然是一个指针：int *arr。

那么，函数内部的sizeof(arr)结果是4。

那该如何设计？

void bubble_sort(int arr[], int sz)//形参arr本质是指针
{
    //确定趟数
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        //一趟冒泡排序的过程
        int j = 0;
        int flag = 1;

        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;
                flag = 0;
            }
        }
        if (flag == 1)
        {
            break;
        }
    }
}
//就在main函数求出sz，然后传给函数就行
int main()
{
    //排序为升序
    //int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
    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;
}

5. 三子棋

三子棋的总体设计和游戏模板

在这里插入图片描述

5.1主函数设计和菜单栏设计：

程序运行，一上来就进入游戏，用do while循环，然后用数字1和2选择，用switch语句

//主函数：
int main()
{
	int input = 0;
	//srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			//printf("三子棋游戏\n");
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，请重新选择\n");
			break;
		}
	} while (input);
	return 0;
}

菜单栏：

void menu()
{
	printf("******************************\n");
	printf("******    1. play        *****\n");
	printf("******    0. exit        *****\n");
	printf("******************************\n");
}

5.2 游戏函数的实现

如上图所示，输入数字1后，屏幕打印出棋盘

//   %c | %c | %c   人走一步，电脑走一步，用不同的标识做记号
//   ---|--- |---
//   %c | %c | %c
//   ---|--- |---
//   %c | %c | %c

像打印出棋盘，显然使用二维数组

5.2.1 存储数据 - 二维数组

//game.h 头文件
//符号定义
#define ROW 3
#define COL 3

char board[ROW][COL];

为什么要define ROW,COl? 万一要实现五子棋怎么，是不是直接修改define里的 ROW 和 COL 的值就可以了！

5.2.2 初始化棋盘

void InitBoard(char board[ROW][COL], int row, int col);

//初始化
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] = ' ';
		}
	}
}

5.2.3 打印棋盘

//打印棋盘
//   %c | %c | %c   
//   ---|--- |---
//   %c | %c | %c
//   ---|--- |---
//   %c | %c | %c
//先打印 %c | %c | %c 
//再打印 ---|--- |---  这两个为一组
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)
{
	//再分析
//   %c | %c | %c   
//   ---|--- |---
//   %c | %c | %c
//   ---|--- |---
//   %c | %c | %c
// 	   你想？如果就一次循环，打印出来的东西就比较固定，没那么灵活，
//     若是用两次循环呢（第一行所有列，再到第二行所有列...）
// 	   按上面的思路，同样是先打印%c | %c | %c和---|--- |---这一组
// 	   用多一次循环打印
	//如果按列打印也是一样，就是%c | 为一组，先打印%c 再打印|
	//最后的printf("---|---|---\n"); 也是先打印---，再打印|
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			//printf(" %c | %c | %c \n", board[i][0], board[i][1], board[i][2]);
			printf(" %c ", board[i][j]);
			if(j < col -1)
			  printf("|");// |不能直接打印，因为它比数少一个
		}
		printf("\n");

		if (i < row - 1)
			//printf("---|---|---\n");
		{
			int j = 0;
			for (j = 0; j < col;j++)
			{
				printf("---");
				if(j < col -1)
				   printf("|");
			}
			printf("\n");

		}
	}
}

5.2.4下棋以及判断游戏状态

下棋：玩家下棋，再到电脑随机下棋（下棋过程中还需讨论下棋的位置是否合理，游戏是否结束），整个游戏都是下棋的过程，除非游戏结束，可使用while循环

游戏状态： 接收游戏状态电脑赢 # 玩家赢 * 平局 Q 继续游戏 C

void game()
{
	//存储数据 - 二维数组
	char board[ROW][COL];
	//初始化数组 -  初始化空格
	InitBoard(board, ROW, COL);
	//打印一下棋盘  - 本质就是打印数组的内容
	DisplayBoard(board, ROW, COL);
	//接收游戏状态   电脑赢 #  玩家赢 * 平局 Q  继续游戏 C
	char ret = 0;
	while (1)
	{
		//玩家下棋
		PlayerMove(board, ROW, COL);
		DisplayBoard(board, ROW, COL);
		//判断玩家是否赢得比赛
		ret = Iswin(board, ROW, COL);
		if (ret != 'C')
			break;
		//电脑下棋
		ComputerMove(board, ROW, COL);
		DisplayBoard(board, ROW, COL);
		//判断电脑是否赢得比赛
		ret = Iswin(board, ROW, COL);
		if (ret != 'C')
			break;
	}
	if (ret == '*')
	{
		printf("玩家赢了\n");
	}
	else if(ret == '#')
	{
		printf("电脑赢了\n");
	}
	else
	{
		printf("平局\n");
	}
}

5.3玩家下棋

玩家下棋：当玩家输入坐标之后，首先判断坐标的合法性；若不合法，就重新输入

有人好奇if (x >= 1 && x <= row && y >= 1 && y <= col)这是为什么？

这是为了方便下棋，把坐标设置成从1开始。

但是存储数据还是得用原来的数组下标，也就是board[x - 1][y - 1],x从1开始，那就是对应着数组下标的0。

void PlayerMove(char board[ROW][COL], int row, int col)
{
	int x = 0;
	int 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;
			}
			else
			{
				printf("坐标被占用，请重新输入\n");
			}
		}
		else
		{
			printf("坐标非法，请重新输入\n");
		}
	}
}

5.4电脑下棋

电脑下棋用的是随机值，在用rand时还需要注意一个点，创建唯一的时间戳（应定义在主函数中）

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

//主函数
srand((unsigned int)time(NULL));

5.5判断游戏状态

每一次下棋之后，都需要判断一下游戏的状态，猜决定下一步是否继续执行。

游戏状态分别为：电脑赢，玩家赢，平局，继续游戏（下棋）

赢的游戏判断：三行一样，三列一样或者两条对角线一样

平局：也就是棋盘满了

继续下棋：以上两种情况都不符合

char Iswin(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	//判断三行
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
		{
			return  board[i][1];//返回的可能是(电脑赢)-#
                                // 玩家赢的符号 - *
		}
	}

	//判断三列
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[1][i] != ' ')
		{
			return board[1][i];
		}
	}

	//判断对角线
	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
	{
		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';

}

int IsFull(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++)
		{
			if (board[i][j] == ' ')
			{
				return 0;//棋盘没满
			}
		}
	}
	return 1;//棋盘满了
}

6.扫雷游戏

**总体设计：**先看程序运行的大致结果

布置雷（先要有存放雷的棋盘）
排查雷

test.c - 扫雷游戏的测试

game.c - 游戏函数的实现

game.h - 游戏函数的声明

在这里插入图片描述

6.1棋盘的设置

在这里插入图片描述

//game.h
#define ROW 9
#define COL 9

#define ROWS ROW+2
#define COLS COL+2

//test.c 的game()函数
char mine[ROWS][COLS] = { 0 };//存放布置好的雷的信息
char show[ROWS][COLS] = { 0 };//存放排查出的雷的信息

6.2初始化棋盘

//test.c 的game()函数
//初始化棋盘
InitBoard(mine, ROWS, COLS, '0');
InitBoard(show, ROWS, COLS, '*');

void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			//board[i][j] = '*' //' '
			board[i][j] = set;
		}
	}
}

6.3打印棋盘

原来初始化的是 11*11的棋盘，现在只需要打印9 * 9的棋盘，另外在棋盘的首行首列打印出0-9的数字，方便下棋

DisplayBoard(show, ROW, COL);//原来初始化的是 11*11的棋盘 ，现在只需打印9*9的棋盘

void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	printf("------------扫雷游戏-----------\n");
	//为了方便查找，打印出行和列数
	//打印列号 0 1 2 3 4 5 (按行的样子打印)
	for (i = 0; i <= col; i++)
	{
		printf("%d ", i);
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		//行
		//打印行号 0
		//       1
		printf("%d ", i);
		for (j = 1; j <= col; j++)
		{
			//列
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
	printf("------------扫雷游戏-----------\n");
}

6.4布置雷

首先要确定雷的个数，为了后期方便修改雷的个数，采用 #define EASY_COUNT 10来定义雷的个数

上面说过有两个棋盘，给mine数组的9*9布置雷

如果mine数组在布置雷的时候，原有的数据是0，说明此处可以布置雷，1表示该位置已经有雷了

//布置雷
void SetMine(char mine[ROWS][COLS], int row, int col)
{
	//布置10个雷
	int count = EASY_COUNT;
	while (count)
	{
		//随机产生下标 1 - 9     rand() % row余数就只有0 - 8
		int x = rand() % row + 1;
		int y = rand() % col + 1;
		//判断
		if ( mine [x][y] == '0')
		{
			mine[x][y] = '1';
			count--;
		}
	}
}

6.5排查雷

输入排查的坐标
检查坐标处是不是雷
- 是雷 - 很遗憾炸死了 - 游戏结束
- 不是雷 - 统计坐标周围有几个雷 - 存储排查雷的信息到show数组，游戏继续

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	//1. 输入排查的坐标
	//2. 检查坐标处是不是雷
	   // (1) 是雷   - 很遗憾炸死了 - 游戏结束
	   // (2) 不是雷  - 统计坐标周围有几个雷 - 存储排查雷的信息到show数组，游戏继续

	int x = 0;
	int y = 0;
	int win = 0;
	while (win < row * col - EASY_COUNT)//win表示下棋个数，若小于总方格减去雷的个数，就继续下
	{
		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
			{
				//不是雷  - 统计坐标周围有几个雷
				int count = get_mine_count(mine, x, y);
				show[x][y] = count + '0';
                //‘0’-48 ‘1’-49  3+'0' = 3,count + '0'
				//显示排查出的信息
				DisplayBoard(show, row, col);
				win++;
			}

		}
		else //输入不合法
		{
			printf("坐标输入不合法，请重新输入\n");
		}
	}
	
	if (win == row * col - EASY_COUNT)
	{
		printf("恭喜你，排雷成功了\n");
		DisplayBoard(mine, row, col);
	}
}

统计坐标周围有几个雷

static int get_mine_count(char mine[ROWS][COLS], int x, int y)
{
	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个雷，如何显示处8呢？上面注释解析的一样 count - 8*'0'
}

**总结：**扫雷游戏一开始最难的地方有：

若只设计9*9的棋盘，那棋盘的四个边角处如何处理？这涉及到后面的-统计坐标周围有几个雷
假设雷-’1‘，不是雷-‘0’ 那棋盘显示出的1是雷还是排查处雷的信息呢？所以才会考虑出设计两个棋盘
屏幕打印的是char show-存放排查出的雷的信息,而雷放在char mine-存放布置好的雷的信息,在布置好雷后，该如何联系呢？

下棋后，在mine数组里检查是否触碰雷，若没触碰，返回周围雷的个数，然后给show数组的该位置赋值，最后打印show数组

{
//不是雷 - 统计坐标周围有几个雷
int count = get_mine_count(mine, x, y);
show[x][y] = count + ‘0’;
//‘0’-48 ‘1’-49 3+‘0’ = 3,count + ‘0’
//显示排查出的信息
DisplayBoard(show, row, col);
win++;
}
```
 }
 else //输入不合法
 {
 	printf("坐标输入不合法，请重新输入\n");
 }
```
}

if (win == row * col - EASY_COUNT)
{
printf(“恭喜你，排雷成功了\n”);
DisplayBoard(mine, row, col);
}
}


统计坐标周围有几个雷

~~~c
static int get_mine_count(char mine[ROWS][COLS], int x, int y)
{
	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个雷，如何显示处8呢？上面注释解析的一样 count - 8*'0'
}

**总结：**扫雷游戏一开始最难的地方有：

若只设计9*9的棋盘，那棋盘的四个边角处如何处理？这涉及到后面的-统计坐标周围有几个雷
假设雷-’1‘，不是雷-‘0’ 那棋盘显示出的1是雷还是排查处雷的信息呢？所以才会考虑出设计两个棋盘
屏幕打印的是char show-存放排查出的雷的信息,而雷放在char mine-存放布置好的雷的信息,在布置好雷后，该如何联系呢？

下棋后，在mine数组里检查是否触碰雷，若没触碰，返回周围雷的个数，然后给show数组的该位置赋值，最后打印show数组