【C语言】数组的应用——三子棋、扫雷

已于 2023-02-21 15:25:35 修改
阅读量601 收藏 1
点赞数
分类专栏： C语言 文章标签： c语言
于 2022-05-22 16:35:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qiuhan_909/article/details/124910704
版权

目录

1. 三子棋

1.1 创建文件

1.2 设计游戏大致流程

1.3 设计菜单

1.4 设计游戏

1.4.1 创建棋盘

1.4.2 初始化棋盘

1.4.3 打印棋盘

1.4.4 下棋

1.4.5 打印结果并打印棋盘

1.5 完整代码

2. 扫雷

2.1 创建文件

2.2 设计游戏大致流程

2.3 设计菜单

2.4 设计游戏

2.4.1 创建棋盘

2.4.2 初始化棋盘

2.4.3 布置雷

2.4.4 打印棋盘

2.4.5 排查雷

2.5 完整代码

1. 三子棋

1.1 创建文件

创建一个头文件game.h：游戏代码的声明（函数声明、符号定义）

创建两个源文件game.c：游戏代码的实现

                            test.c：测试游戏的逻辑

1.2 设计游戏大致流程

游戏流程至少执行1次，所以用do while循环。

  1. 打印菜单：1. play 0. exit
  2. 玩家输入1/0选择是否进入游戏
  3. 输入1，进入游戏；输入0，退出游戏；输入其他，提示选择错误后再次进入循环
//test.c
int main()
{
	int input = 0;
	do
	{
		//打印菜单
        menu();
        //玩家输入1/0选择是否进入游戏
		printf("请选择:>");
		scanf("%d", &input);
        //输入1，进入游戏；输入0，退出游戏；输入其他，提示选择错误后再次进入循环
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误!\n");
			break;
		}
	} while (input);
	return 0;
}
//game.h
//源文件需要的头文件可以写在game.h中，这样源文件只要包含了game.h就包含了这些头文件
#include <stdio.h>

1.3 设计菜单

//test.c
//菜单
void menu()
{
	printf("*****************************\n");
	printf("*****  1. play  0. exit *****\n");
	printf("*****************************\n");
}

1.4 设计游戏

1.4.1 创建棋盘

创建3×3的二维数组当作棋盘，在game.h中定义ROW和COL的值均为3，这样如果要修改ROW和COL的值，只需要在game.h中修改即可。

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
}
//game.h
//如果要修改ROW和COL的值，只需要修改#define这两行代码即可
#define ROW 3
#define COL 3

1.4.2 初始化棋盘

遍历二维数组， 令二维数组每个元素都是空格。

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
    //初始化棋盘
	InitBoard(board, ROW, COL);
}
//game.c
//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
        int j = 0;
		for (j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
	}
}
//game.h
//初始化棋盘函数声明
void InitBoard(char board[ROW][COL], int row, int col);

1.4.3 打印棋盘

打印棋子和网格。

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
    //初始化棋盘
	InitBoard(board, ROW, COL);
    //打印棋盘
	DispalyBoard(board, ROW, COL);
}

打印棋盘函数版本1——容易看懂版：

//game.c
//打印棋盘
void DispalyBoard(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");
	}
}

打印棋盘函数版本2——高大上版：

//game.c
//打印棋盘
void DispalyBoard(char board[ROW][COL], int row, int col)
{
	int i = 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)
		{
			int j = 0;
			for (j = 0; j < col; j++)
			{
				printf("---");
				if (j < col - 1)
					printf("|");
			}
			printf("\n");
		}
	}
}
//game.h
//打印棋盘函数声明
void DispalyBoard(char board[ROW][COL], int row, int col);

棋盘展示：

1.4.4 下棋

双方下棋过程是无限循环的，直到有一方赢了或平局，跳出循环，结束下棋，所以下棋过程放在while(1)循环内。

玩家的棋子为*，电脑的棋子为#。

1.4.4.1 玩家下棋

数组的下标是从0开始的，而玩家认为行和列的坐标都是从1开始的，如图所示：

123
1棋盘格棋盘格棋盘格
2棋盘格棋盘格棋盘格
3棋盘格棋盘格棋盘格

玩家可能会输入被占用的或棋盘外的坐标，此时需要重新下棋，如果一直输入错误，则玩家下棋无限循环，直到输入合法的坐标，跳出循环，结束玩家下棋，所以玩家下棋放在while(1)循环内。

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
    //初始化棋盘
	InitBoard(board, ROW, COL);
    //打印棋盘
	DispalyBoard(board, ROW, COL);
    //下棋
	while (1)
	{
		//玩家下棋
        PlayerMove(board, ROW, COL);
	}
}
//game.c
//玩家下棋
void PlayerMove(char board[ROW][COL], int row, int col)
{
	printf("玩家下棋:>\n");
	while (1)
	{
        int x = 0;
	    int y = 0;
        //输入下棋坐标
		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");
	}
}
//game.h
//玩家下棋函数声明
void PlayerMove(char board[ROW][COL], int row, int col);

1.4.4.2 判断输赢

设计判断输赢函数，返回类型为char型，所以要先创建一个char型变量ret，用于接收返回值。如果行或列或对角线三个棋子相同，则返回棋子（即玩家赢返回*，电脑赢返回#）。平局返回D，继续返回C。如果玩家赢或电脑赢或平局，则跳出循环，结束下棋。

平局即棋盘被占满的情况，设计判断棋盘是否被占满函数，返回类型为int型，被占满返回1，没被占满返回0。

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
    //初始化棋盘
	InitBoard(board, ROW, COL);
    //打印棋盘
	DispalyBoard(board, ROW, COL);
    //下棋
	char ret = 0;
	while (1)
	{
		//玩家下棋
        PlayerMove(board, ROW, COL);
        //判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
	}
}
//game.c
//判断输赢
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][1] != ' ')
			return board[i][1];
	}
	//列
	int j = 0;
	for (j = 0; j < col; j++)
	{
		if (board[0][j] == board[1][j] && board[1][j] == board[2][j] && board[1][j] != ' ')
			return board[1][j];
	}
	//对角线
	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];
	//平局
	if (IsFull(board, row, col))
		return 'D';
	//继续
	return 'C';
}
//game.h
//判断输赢函数声明
char IsWin(char board[ROW][COL], int row, int col);
//game.c
//判断棋盘是否被占满
int IsFull(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
    	int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
				return 0;//没被占满返回0
		}
	}
	return 1;//被占满返回1
}

1.4.4.3 打印棋盘

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
    //初始化棋盘
	InitBoard(board, ROW, COL);
    //打印棋盘
	DispalyBoard(board, ROW, COL);
    //下棋
	char ret = 0;
	while (1)
	{
		//玩家下棋
        PlayerMove(board, ROW, COL);
        //判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
        //打印棋盘
		DispalyBoard(board, ROW, COL);
	}
}

1.4.4.4 电脑下棋

电脑在空格子随机下棋，需要在循环内使用rand()函数，循环外使用srand((unsigned int)time(NULL))使每次生成的随机数序列都是不同的。

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
    //初始化棋盘
	InitBoard(board, ROW, COL);
    //打印棋盘
	DispalyBoard(board, ROW, COL);
    //下棋
	char ret = 0;
	while (1)
	{
		//玩家下棋
        PlayerMove(board, ROW, COL);
        //判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
        //打印棋盘
		DispalyBoard(board, ROW, COL);
        //电脑下棋
		ComputerMove(board, ROW, COL);
	}
}

int main()
{
    //设置随机数种子
	srand((unsigned int)time(NULL));
	int input = 0;
	do
	{
		//打印菜单
        menu();
        //玩家输入1/0选择是否进入游戏
		printf("请选择:>");
		scanf("%d", &input);
        //输入1，进入游戏；输入0，退出游戏；输入其他，提示选择错误后再次进入循环
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误!\n");
			break;
		}
	} while (input);
	return 0;
}
//game.c
//电脑下棋
void ComputerMove(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋:>\n");
	while (1)
	{
		int x = rand() % row;//0~2
		int y = rand() % col;//0~2
		if (board[x][y] == ' ')
		{
			board[x][y] = '#';
			break;
		}
	}
}
//game.h
//源文件需要的头文件可以写在game.h中，这样源文件只要包含了game.h就包含了这些头文件
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//电脑下棋函数声明
void ComputerMove(char board[ROW][COL], int row, int col);

1.4.4.5 判断输赢

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
    //初始化棋盘
	InitBoard(board, ROW, COL);
    //打印棋盘
	DispalyBoard(board, ROW, COL);
    //下棋
	char ret = 0;
	while (1)
	{
		//玩家下棋
        PlayerMove(board, ROW, COL);
        //判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
        //打印棋盘
		DispalyBoard(board, ROW, COL);
        //电脑下棋
		ComputerMove(board, ROW, COL);
        //判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
	}
}

1.4.4.6 打印棋盘

//test.c
//游戏
void game()
{
    //创建棋盘
	char board[ROW][COL] = { 0 };
    //初始化棋盘
	InitBoard(board, ROW, COL);
    //打印棋盘
	DispalyBoard(board, ROW, COL);
    //下棋
	char ret = 0;
	while (1)
	{
		//玩家下棋
        PlayerMove(board, ROW, COL);
        //判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
        //打印棋盘
		DispalyBoard(board, ROW, COL);
        //电脑下棋
		ComputerMove(board, ROW, COL);
        //判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
        //打印棋盘
		DispalyBoard(board, ROW, COL);
	}
}

1.4.5 打印结果并打印棋盘

//test.c
//游戏
void game()
{
	//创建棋盘
	char board[ROW][COL] = { 0 };
	//初始化棋盘
	InitBoard(board, ROW, COL);
	//打印棋盘
	DispalyBoard(board, ROW, COL);
	//下棋
	char ret = 0;
	while (1)
	{
		//玩家下棋
		PlayerMove(board, ROW, COL);
		//判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
		//打印棋盘
		DispalyBoard(board, ROW, COL);
		//电脑下棋
		ComputerMove(board, ROW, COL);
		//判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
		//打印棋盘
		DispalyBoard(board, ROW, COL);
	}
	//打印结果
	if (ret == '*')
		printf("玩家赢\n");
	else if (ret == '#')
		printf("电脑赢\n");
	else
		printf("平局\n");
	//打印棋盘
	DispalyBoard(board, ROW, COL);
}

1.5 完整代码

game.h：

#pragma once//预处理指令，保证头文件只能被编译一次

//源文件需要的头文件可以写在game.h中，这样源文件只要包含了game.h就包含了这些头文件
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

//如果要修改ROW和COL的值，只需要修改#define这两行代码即可
#define ROW 3
#define COL 3

//初始化棋盘函数声明
void InitBoard(char board[ROW][COL], int row, int col);
//打印棋盘函数声明
void DispalyBoard(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);

game.c：

#include "game.h"

//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
	}
}

//打印棋盘1
//void DispalyBoard(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");
//	}
//}

//打印棋盘2
void DispalyBoard(char board[ROW][COL], int row, int col)
{
	int i = 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)
		{
			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)
{
	printf("玩家下棋:>\n");
	while (1)
	{
		int x = 0;
		int y = 0;
		//输入下棋坐标
		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");
	}
}

//电脑下棋
void ComputerMove(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋:>\n");
	while (1)
	{
		int x = rand() % row;//0~2
		int y = rand() % col;//0~2
		if (board[x][y] == ' ')
		{
			board[x][y] = '#';
			break;
		}
	}
}

//判断棋盘是否被占满
int IsFull(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
				return 0;//没被占满返回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][1] != ' ')
			return board[i][1];
	}
	//列
	int j = 0;
	for (j = 0; j < col; j++)
	{
		if (board[0][j] == board[1][j] && board[1][j] == board[2][j] && board[1][j] != ' ')
			return board[1][j];
	}
	//对角线
	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];
	//平局
	if (IsFull(board, row, col))
		return 'D';
	//继续
	return 'C';
}

test.c：

#include "game.h"

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

//游戏
void game()
{
	//创建棋盘
	char board[ROW][COL] = { 0 };
	//初始化棋盘
	InitBoard(board, ROW, COL);
	//打印棋盘
	DispalyBoard(board, ROW, COL);
	//下棋
	char ret = 0;
	while (1)
	{
		//玩家下棋
		PlayerMove(board, ROW, COL);
		//判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
		//打印棋盘
		DispalyBoard(board, ROW, COL);
		//电脑下棋
		ComputerMove(board, ROW, COL);
		//判断输赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
			break;
		//打印棋盘
		DispalyBoard(board, ROW, COL);
	}
	//打印结果
	if (ret == '*')
		printf("玩家赢\n");
	else if (ret == '#')
		printf("电脑赢\n");
	else
		printf("平局\n");
	//打印棋盘
	DispalyBoard(board, ROW, COL);
}

int main()
{
	//设置随机数种子
	srand((unsigned int)time(NULL));	
    int input = 0;
	do
	{
		//打印菜单
		menu();
		//玩家输入1/0选择是否进入游戏
		printf("请选择:>");
		scanf("%d", &input);
		//输入1，进入游戏；输入0，退出游戏；输入其他，提示选择错误后再次进入循环
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误!\n");
			break;
		}
	} while (input);
	return 0;
}

运行结果：

2. 扫雷

2.1 创建文件

创建一个头文件game.h：游戏代码的声明（函数声明、符号定义）

创建两个源文件game.c：游戏代码的实现

                            test.c：测试游戏的逻辑

2.2 设计游戏大致流程

游戏流程至少执行1次，所以用do while循环。

  1. 打印菜单：1. play 0. exit
  2. 玩家输入1/0选择是否进入游戏
  3. 输入1，进入游戏；输入0，退出游戏；输入其他，提示选择错误后再次进入循环
//test.c
int main()
{
	int input = 0;
	do
	{
		//打印菜单
        menu();
        //玩家输入1/0选择是否进入游戏
		printf("请选择:>");
		scanf("%d", &input);
        //输入1，进入游戏；输入0，退出游戏；输入其他，提示选择错误后再次进入循环
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误!\n");
			break;
		}
	} while (input);
	return 0;
}
//game.h
//源文件需要的头文件可以写在game.h中，这样源文件只要包含了game.h就包含了这些头文件
#include <stdio.h>

2.3 设计菜单

//test.c
//菜单
void menu()
{
	printf("*****************************\n");
	printf("*****  1. play  0. exit *****\n");
	printf("*****************************\n");
}

2.4 设计游戏

2.4.1 创建棋盘

要想展示9×9的棋盘，就要创建11×11的二维数组。因为计算一个坐标周围的雷的个数时，会计算周围八个坐标中雷的个数之和，当坐标为边界时，计算周围的雷的个数会发生数组越界，所以应在9×9的基础上增加两行两列，创建11×11的二维数组。

创建2个11×11的二维数组，一个用来存放布置好的雷的信息，一个用来存放排查出的雷的信息。

//test.c
//游戏
void game()
{
    //创建棋盘
    //存放布置好的雷的信息
	char mine[ROWS][COLS] = { 0 };
    //存放排查出的雷的信息
	char show[ROWS][COLS] = { 0 };
}
//game.h
//如果要修改ROW和COL的值，只需要修改#define这几行代码即可
#define ROW 3
#define COL 3
#define ROWS ROW+2
#define COLS COL+2

2.4.2 初始化棋盘

遍历二维数组， 令二维数组每个元素都是指定内容。mine数组全部初始化为'0'，show数组全部初始化为'*'。

//test.c
//游戏
void game()
{
    //创建棋盘
    //存放布置好的雷的信息
	char mine[ROWS][COLS] = { 0 };
    //存放排查出的雷的信息
	char show[ROWS][COLS] = { 0 };
	//初始化棋盘
    //全部初始化为'0'
	InitBoard(mine, ROWS, COLS, '0');
    //全部初始化为'*'
	InitBoard(show, ROWS, COLS, '*');
}
//game.c
//初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	for (i = 0; i < rows; i++)
	{
		int j = 0;
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}
//game.h
//初始化棋盘函数声明
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)

2.4.3 布置雷

电脑在mine数组的下标1~9的81个元素中随机布置雷，下标0和10为拓展的两行两列，不能布置雷，用1表示雷，定义简单模式下有10个雷。随机布置雷需要在循环内使用rand()函数，循环外使用srand((unsigned int)time(NULL))使每次生成的随机数序列都是不同的。

//test.c
//游戏
void game()
{
    //创建棋盘
    //存放布置好的雷的信息
	char mine[ROWS][COLS] = { 0 };
    //存放排查出的雷的信息
	char show[ROWS][COLS] = { 0 };
	//初始化棋盘
    //全部初始化为'0'
	InitBoard(mine, ROWS, COLS, '0');
    //全部初始化为'*'
	InitBoard(show, ROWS, COLS, '*');
	//布置雷
	SetMine(mine, ROW, COL);
}

int main()
{
	//设置随机数种子
	srand((unsigned int)time(NULL));
	int input = 0;
	do
	{
		//打印菜单
		menu();
		//玩家输入1/0选择是否进入游戏
		printf("请选择:>");
		scanf("%d", &input);
		//输入1，进入游戏；输入0，退出游戏；输入其他，提示选择错误后再次进入循环
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误!\n");
			break;
		}
	} while (input);
	return 0;
}
//game.c
//布置雷
void SetMine(char board[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;
	while (count)
	{
		int x = rand() % row + 1;//1~9
		int y = rand() % col + 1;//1~9
		if (board[x][y] == '0')
		{
			board[x][y] = '1';
			count--;
		}
	}
}
//game.h
//源文件需要的头文件可以写在game.h中，这样源文件只要包含了game.h就包含了这些头文件
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//定义雷的个数
#define EASY_COUNT 10
//布置雷函数声明
void SetMine(char board[ROWS][COLS], int row, int col);

2.4.4 打印棋盘

打印数组元素和棋盘坐标系。

游戏过程中打印show数组的元素，没被排查的坐标为'*'，被排查的坐标为周围的雷的个数（数字字符）。

游戏结束时打印mine数组的元素，即布置好的雷的信息。

//test.c
//游戏
void game()
{
    //创建棋盘
    //存放布置好的雷的信息
	char mine[ROWS][COLS] = { 0 };
    //存放排查出的雷的信息
	char show[ROWS][COLS] = { 0 };
	//初始化棋盘
    //全部初始化为'0'
	InitBoard(mine, ROWS, COLS, '0');
    //全部初始化为'*'
	InitBoard(show, ROWS, COLS, '*');
	//布置雷
	SetMine(mine, ROW, COL);
    //打印show棋盘
	DisplayBoard(show, ROW, COL);
}
//game.c
//打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	int i = 0;
	int j = 0;
    //打印分割线
	printf("------扫雷游戏------\n");
    //打印0 1 2 3 4 5 6 7 8 9（横轴）
	for (j = 0; j <= col; j++)
	{
		printf("%d ", j);
	}
	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");
}
//game.h
//打印棋盘函数声明
void DisplayBoard(char board[ROWS][COLS], int row, int col);

show棋盘展示：

 

mine棋盘展示：

2.4.5 排查雷

计算坐标周围的雷的个数，即计算mine数组中该坐标周围八个坐标的数字之和。

(x-1,y-1)(x,y-1)(x+1,y-1)
(x-1,y)(x,y)(x+1,y)
(x-1,y+1)(x,y+1)(x+1,y+1)
//test.c
//游戏
void game()
{
    //创建棋盘
    //存放布置好的雷的信息
	char mine[ROWS][COLS] = { 0 };
    //存放排查出的雷的信息
	char show[ROWS][COLS] = { 0 };
	//初始化棋盘
    //全部初始化为'0'
	InitBoard(mine, ROWS, COLS, '0');
    //全部初始化为'*'
	InitBoard(show, ROWS, COLS, '*');
	//布置雷
	SetMine(mine, ROW, COL);
    //打印show棋盘
	DisplayBoard(show, ROW, COL);
	//排查雷
	FindMine(mine, show, ROW, COL);
}
//game.c
//排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int win = 0;//找到的非雷的个数
	//循环排雷
	while (win < row * col - EASY_COUNT)
	{
		int x = 0;
		int y = 0;
		//输入排雷坐标
		printf("请输入要排查的坐标:>");
		scanf("%d %d", &x, &y);
		//坐标合法
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			//没排查过
			if (show[x][y] = '*')
			{
				//是雷
				if (mine[x][y] == '1')
				{
					printf("很遗憾，你被炸死了\n");
					//打印mine棋盘
					DisplayBoard(mine, ROW, COL);
					break;
				}
				//不是雷
				else
				{
					win++;
					//计算坐标周围的雷的个数
					int count = get_mine_count(mine, x, y);
					//将整型的雷的个数转化为字符型，存入数组
					show[x][y] = count + '0';//+'0'的ASCII码值，转化为字符型
					//打印show棋盘
					DisplayBoard(show, ROW, COL);
				}
			}
			//排查过
			else
				printf("该坐标被排查过了，不能重复排查\n");
		}
	    //坐标非法
	    else
			printf("输入的坐标非法,请重新输入\n");
	}
    //排雷成功
	if (win == row * col - EASY_COUNT)
	{
		printf("恭喜你，排雷成功\n");
		//打印mine棋盘
		DisplayBoard(mine, ROW, COL);
	}
}
//game.h
//排查雷函数声明
void SetMine(char board[ROWS][COLS], int row, int col);
//game.c
//计算坐标周围的雷的个数
int get_mine_count(char board[ROWS][COLS], int x, int y)
{
	return (board[x - 1][y] +
		board[x - 1][y - 1] +
		board[x][y - 1] +
		board[x + 1][y - 1] +
		board[x + 1][y] +
		board[x + 1][y + 1] +
		board[x][y + 1] +
		board[x - 1][y + 1] - 8 * '0');//8个字符型数字相加-8个'0'的ASCII码值，转化为整型
}

2.5 完整代码

game.h：

#pragma once//预处理指令，保证头文件只能被编译一次

//源文件需要的头文件可以写在game.h中，这样源文件只要包含了game.h就包含了这些头文件
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

//如果要修改ROW和COL的值，只需要修改#define这几行代码即可
#define ROW 9
#define COL 9
#define ROWS ROW+2
#define COLS COL+2
#define EASY_COUNT 10

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

game.c：

#include "game.h"

//初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	for (i = 0; i < rows; i++)
	{
		int j = 0;
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}

//布置雷
void SetMine(char board[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;
	while (count)
	{
		int x = rand() % row + 1;//1~9
		int y = rand() % col + 1;//1~9
		if (board[x][y] == '0')
		{
			board[x][y] = '1';
			count--;
		}
	}
}

//打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	//打印分割线
	printf("------扫雷游戏------\n");
	//打印0 1 2 3 4 5 6 7 8 9（横轴）
	for (j = 0; j <= col; j++)
	{
		printf("%d ", j);
	}
	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");
}

//计算坐标周围的雷的个数
int get_mine_count(char board[ROWS][COLS], int x, int y)
{
	return (board[x - 1][y] +
		board[x - 1][y - 1] +
		board[x][y - 1] +
		board[x + 1][y - 1] +
		board[x + 1][y] +
		board[x + 1][y + 1] +
		board[x][y + 1] +
		board[x - 1][y + 1] - 8 * '0');//8个字符型数字相加-8个'0'的ASCII码值，转化为整型
}

//排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int win = 0;//找到的非雷的个数
	//循环排雷
	while (win < row * col - EASY_COUNT)
	{
		int x = 0;
		int y = 0;
		//输入排雷坐标
		printf("请输入要排查的坐标:>");
		scanf("%d %d", &x, &y);
		//坐标合法
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			//没排查过
			if (show[x][y] = '*')
			{
				//是雷
				if (mine[x][y] == '1')
				{
					printf("很遗憾，你被炸死了\n");
					//打印mine棋盘
					DisplayBoard(mine, ROW, COL);
					break;
				}
				//不是雷
				else
				{
					win++;
					//计算坐标四周的雷的个数
					int count = get_mine_count(mine, x, y);
					//将整型的雷的个数转化为字符型，存入数组
					show[x][y] = count + '0';//+'0'的ASCII码值，转化为字符型
					//打印show棋盘
					DisplayBoard(show, ROW, COL);
				}
			}
			//排查过
			else
				printf("该坐标被排查过了，不能重复排查\n");
		}
	    //坐标非法
	    else
			printf("输入的坐标非法,请重新输入\n");
	}
    //排雷成功
	if (win == row * col - EASY_COUNT)
	{
		printf("恭喜你，排雷成功\n");
		//打印mine棋盘
		DisplayBoard(mine, ROW, COL);
	}
}

 test.c：

#include "game.h"

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

//游戏
void game()
{
	//创建棋盘
	//存放布置好的雷的信息
	char mine[ROWS][COLS] = { 0 };
	//存放排查出的雷的信息
	char show[ROWS][COLS] = { 0 };
	//初始化棋盘
	//全部初始化为'0'
	InitBoard(mine, ROWS, COLS, '0');
	//全部初始化为'*'
	InitBoard(show, ROWS, COLS, '*');
	//布置雷
	SetMine(mine, ROW, COL);
	//打印show棋盘
	DisplayBoard(show, ROW, COL);
	//排查雷
	FindMine(mine, show, ROW, COL);
}

int main()
{
	//设置随机数种子
	srand((unsigned int)time(NULL));
	int input = 0;
	do
	{
		//打印菜单
		menu();
		//玩家输入1/0选择是否进入游戏
		printf("请选择:>");
		scanf("%d", &input);
		//输入1，进入游戏；输入0，退出游戏；输入其他，提示选择错误后再次进入循环
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误!\n");
			break;
		}
	} while (input);
	return 0;
}

运行结果：

 

秋秋晗晗
关注
专栏目录
C语言 数组的应用————扫雷
weixin_64099089的博客
03-13 2462
在上一篇博客中我们实现了简单的三子棋小游戏，初步运用了二维数组，今天还是用二维数组来实现另一个小游戏——扫雷的基础版本，写这两个小游戏的目的主要是理解并运用数组，同时巩固前面学习的知识比如循环和函数等等，将其结合具体情况解决我们的需要。
C语言——数组（三子棋与扫雷）
有时间要学习的博客
01-02 937
目录一.数组1.数组2.数组的创建3.数组的初始化 4.数组的使用5.数组在内存中的存储二.二维数组 1.二维数组的创建2.二维数组的初始化 3.二维数组的使用4.二维数组在内存中的存储 三数组越界四数组传参4.1问题4.2数组名4.3冒泡排序的正确设计五.三子棋5.1打印棋盘 5.2玩家下棋5.3电脑下棋5.4输赢的判断 5.5输赢的优化 5.6AI下棋六.扫雷6.1棋盘的打印6.2埋雷6.3排雷6.4排雷的优化数组是相同元素的集合体，在这里，我们说的数组通常指的是一维数组。 注：数组创建，在C99标
鹏哥C语言复习——三子棋
2302_80297338的博客
02-12 1849
本文对三子棋游戏所有功能实现进行了详细讲解，敬请阅读
C语言初阶——三子棋
m0_53485626的博客
01-19 2951
C语言初学者就能写的三子棋小游戏，快来看看吧！！！
C语言——三子棋游戏
weil_li的博客
09-14 767
c语言-三子棋游戏，内含代码源文件，详细代码注释，手把手教你如何实现三子棋，干货满满
【C语言基本知识——数组和三子棋小游戏】
weixin_64993156的博客
02-18 118
数组是一组相同类型元素的集合 ，在本篇文章中，分别从 一维数组和二维数组的创建、初始化、使用和在内存中的存储等方面的详细介绍相关的知识点，深入考虑数组作为函数的参数的情况，并且教会C语言的初学者可以通过学习到C语言就可以创建自己的小游戏项目，这篇文章中提到的小游戏项目是：三子棋。
C/C++语言实现——三子棋
qq_62270879的博客
05-07 2094
目录 1.三子棋预估功能分析 2.三子棋各功能实现 3.三子棋代码呈现 前言：相信大家都玩过各种各样的小游戏，比如有：三子棋、五子棋、扫雷、贪吃蛇、推箱子...... 身为一名小小程序员，你是否有想自己做出这些小游戏的冲动呢？今天给大家带来的是“三子棋”的 分享，希望对大家代码的学习有些许的帮助! 1.三子棋预估功能分析 这部分，体现的时整体思路的框架，在没正式写程序之前的功能预估判断，当然也需要在之后开始写的时候再补充。 现在要做的就是从一张白纸上想，如何...
（C语言）用C语言编写小游戏——三子棋
m0_64051621的博客
07-30 3281
用C语言实现的简易三子棋游戏
C语言——数组
qq_59702185的博客
04-16 800
文章目录C语言——数组1.一维数组的创建和初始化2.一维数组的使用3.一维数组在内存中的存储4.二维数组的创建和初始化5.二维数组的使用 C语言——数组 本章重点 1.一维数组的创建和初始化 2.一维数组的使用 3.一维数组在内存中的存储 4.二维数组的创建及初始化 5.二维数组的使用 6.二维数组在内存中的存储 7.数组作为函数参数 8.数组的应用实例1：三子棋 9.数组的应用实例2：扫雷游戏 1.一维数组的创建和初始化 数组的创建 当我们需要存储很多个相同类型数据的时候，就出现了数组。数组是一组相
C语言——数组篇
m0_67910848的博客
11-12 996
3000字包你学懂数组，这你还不来看看，早看早会！
【C语言项目实战4——数组的以及应用】
weixin_64993156的博客
02-21 965
数组是指一组数据的集合，数组中的每个数据称为元素，在数组中可以存放任意类型的元素，但是同一个数组里存放的元素类型必须一致，每个元素可以通过一个索引(下标)来访问他们，并且数据可以分为一维数组和二维数组。数组在C语言当中是极其重要的知识点，在通过学习数组的相关知识点后，就可以开始建立一些小型的项目，例如扫雷，五子棋，在我的相关文章都是有分类的，可以先学习相关的数组知识点，在通过实战练习巩固知识点，最后完成自己的打一个小型项目。
C语言数组
fuxiaopangfyy的博客
11-21 1322
C语言数组
C语言从入门到精通——初阶4 数组
m0_58125693的博客
03-16 1139
57 一维数组 创建和初始化 数组是一组相同类型元素的集合 数组的创建： type_t arr_name [const_n]; //type是指数组的元素类型 //const_n是一个常量表达式，来指定数组的大小 数组的初始化在创建数组的同时给数组的内容一些合理初始值。 不完全初始化时，剩下的元素默认初始化为0 strlen只能求字符串长度，库函数，需要引用头文件 sizeof计算变量，数组，类型的大小，单位是字节，是操作符 数组时使用下标来访问的，下标是从0开始 数组的
C语言进阶——通讯录模拟实现
热门推荐
麦麦的博客
02-13 1万+
C语言进阶——通讯录：本文采取结构体来实现基本的通讯录，有图有码，讲解详细，干货满满，不容错过的好文！
【python进阶攻略12】C扩展
kaggle expert，全球排名前1000，清华计算机研究生，兴趣算法工程
10-01 1144
CPython还为开发者实现了一个有趣的特性，使用Python可以轻松调用C代码开发者有三种方法可以在自己的Python代码中来调用C编写的函数-ctypesSWIG。每种方式也都有各自的利弊。首先，我们要明确为什么要在Python中调用C？
C/C++语言三大结构练习题(持续更新。。。)
2302_76679440的博客
10-02 355
【代码】C/C++语言三大结构练习题(持续更新。。。
基于JavaScript的human-resource-backend后端开发源码设计
10-05
该项目是一款以JavaScript为主语言的HR（人力资源）后端开发源码，集成了Java、CSS、Vue和HTML等多种语言，共计1035个文件。具体文件构成如下：236个Java文件、179个JavaScript文件、104个PNG图片文件、59个CSS文件、56个Vue文件、54个GIF动画文件、42个类文件、41个XML文件、36个SVG文件、35个HTML文件。该后端系统旨在构建一个高效的人力资源管理平台。
基于Java的SpringCloud脚手架及Vue前端设计源码
最新发布
10-05
该项目是一款基于Java的SpringCloud微服务架构的脚手架，同时融合了Vue前端技术。项目包含131个文件，其中Java源代码文件50个，Vue组件文件19个，JavaScript和HTML/CSS相关文件共计38个，XML配置文件13个，YAML文件8个，JSON文件4个，图片文件3个，Git忽略配置文件2个，Markdown文件2个，HTML文件2个。项目结构清晰，功能完善，适用于快速开发和部署微服务应用。
C语言二维数组实现三子棋基础教程
在C语言中实现一个简单的三子棋程序，主要涉及到二维数组的运用。程序结构分为三个部分：头文件（game.h）用于声明函数和定义宏，主函数（test.c）调用这些函数，以及函数实现文件（game.c）。 1. 二维数组的创建与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值