C语言实现简易版和改进版三子棋（分文件编写）
简易版：
先给出运行的截图：
1.首先将文件分好，一个game.h进行对各个函数的声明和头文件的包含，game.cpp实现在game.h中声明的函数，三子棋7_5.cpp则为main()函数主体部分，进行各个框架的实现。
2.然后在main()函数中将整体的框架打出来，首先需要一个菜单界面，提示用户输入进行选择是否开始游戏，输入1则开始进行游戏，程序进入game()函数。其中menu()菜单单独封装成一个函数，由于这个函数较为简单，也不涉及参数的传递和值得返回，就直接写在main()之前了。game()函数也同理。
void menu() {
printf("----------------------\n");
printf("----1.play 2.exit----\n");
printf("----------------------\n");
}int main() {
int input=0;
menu();
printf("请输入您的选择:\n");
scanf("%d", &input);
switch (input) {
case 1:
printf("三子棋游戏开始\n");
game();
break;
case 2:
printf("退出游戏\n");
break;
default:
printf("您输入的值有误\n");
break;
}
return 0;
}运行起来后就是这个样子：
考虑到进行一次游戏想要再玩一把，不断的进行新的选择，直至选择退出游戏。需要使用do {}while()将代码包括起来
do {
menu();
printf("请输入您的选择:\n");
scanf("%d", &input);
switch (input) {
case 1:
printf("三子棋游戏开始\n");
game();
break;
case 2:
printf("退出游戏\n");
break;
default:
printf("您输入的值有误\n");
break;
}
} while (input!=2);3.框架打好后，就开始进行游戏内部的细节处理了。先要想办法把三子棋棋盘打印出来。先进行较为简单的棋盘打印，直接固定为3*3的棋盘。打印成如下形状较为合理。
先在game.h中创建好打印函数的声明，同时可以将棋盘的行和列进行宏定义，以便后续的修改。考虑到棋盘的规模与形状，使用一个二维数组可以很好的符合要求，同时为了方便处理，棋盘的行列也作为了形式参数。
#define ROW 3
#define COL 3
//打印函数
void PrintBoard(char board[ROW][COL], int row, int col);
接着在对应的game.cpp中进行该函数的实现。（后续每个函数都是头文件里声明，源文件里实现，不再重复赘述）通过观察发现棋盘刚开始里面全部都是空格，所以我们在打印棋盘前先要将棋盘初始化为空格，使用两层循环即可。
//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
board[i][j] = ' ';
}
}
}然后再进行对棋盘的打印，观察发现我们可以将棋盘进行分组打印，一行信息为一组，而且在最后一组中没有底部的虚线。每一组中打印完一个空格后，都有一条竖线进行分隔，同时要注意最后一个空格打印完后是没有竖线的。由此可以发现先用两层循环将一组的棋盘打印出来，注意末尾的特殊处理，然后内层循环结束后再用一层循环将底部的横向分割线打印出来，从而完成一组的打印，这里也要注意末尾的线要特殊处理。
//打印棋盘
void PrintBoard(char board[ROW][COL], int row, int col) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
printf(" %c ", board[i][j]);
if (j < col - 1)
printf("|");
}
printf("\n");
if (i < row - 1) {
for (int k = 0; k < col; k++) {
printf("---");
if (k < col - 1)
printf("|");
}
printf("\n");
}
}
}
在game()函数中调用这两个函数
void game() {
char ret;
char board[ROW][COL] = { 0 };
//初始化棋盘
InitBoard(board, ROW, COL);
//打印棋盘
PrintBoard(board, ROW, COL);
}
整体代码运行起来应该是这个样子
4.棋盘打印完后，需要进行下棋的操作了，下棋又分为玩家下棋和电脑下棋，先实现玩家下棋。下棋需要靠坐标实现，用户输入坐标后，进行下一步操作。
玩家下棋又分为三种情况：1.下的位置正确，要显示出玩家的棋子。2.下的位置正确，但是这个位置已经被下过了，不能够再下。3.下的位置不正确，要重新下。
我们以乘号：*来表示玩家的棋子，如果是情况1，就直接将二维数组该位置的值设为*号。如果是情况2，就直接打印一条提示语句，提醒用户重新下棋。为了实现重复下棋，需要一个循环包括住整个代码
//玩家下棋
void PlayerMove(char board[ROW][COL], int row, int col) {
int x = 0;
int y = 0;
printf("玩家下棋：\n");
printf("请输入您要下的坐标：\n");
while (1) {
scanf("%d%d", &x, &y);
if (x<1 || x>row || y<1 || y>col)
printf("输入的值有误,请重新输入\n");
else {
if (board[x-1][y-1] == ' ') {
board[x - 1][y - 1] = '*';
break;
}
else
printf("该位置已经被占，请到其它位置下棋\n");
}
}
}
紧接着就进行电脑下棋的操作，将电脑的棋子设置为：#，对电脑下棋进行较为简单的操作。直接让电脑在棋盘合法的位置上随机下棋，这需要使用rand()函数对棋盘的行列进行取余操作。再通过分支语句将指定位置置为：#。同理为了让电脑能够正确的下棋也需要使用循环包含整体代码。需要注意的是rand()产生的是伪随机数，为了真正实现随机还要在main()函数中设置随机数种子：
srand((unsigned int)time(NULL));电脑下棋的整体代码：
//电脑下棋
void ComputerMove(char board[ROW][COL], int row, int col) {
int x = 0;
int y = 0;
printf("电脑下棋:\n");
while (1) {
x = rand() % row;
y = rand() % col;
if (board[x][y] == ' ') {
board[x][y] = '#';
break;
}
}
}同时在game()函数中也要注意对这两个函数的循环调用，由于每下一次棋后为了更直观地观察，我们需要调用打印棋盘的函数，而且下棋不只下一次，所以要用循环。（这里还不是最终的，所以先用死循环来测试代码，之后再进行处理）
void game() {
char ret;
char board[ROW][COL] = { 0 };
//初始化棋盘
InitBoard(board, ROW, COL);
//打印棋盘
PrintBoard(board, ROW, COL);
while (1) {
//玩家下棋
PlayerMove(board, ROW, COL);
//判断输赢
PrintBoard(board, ROW, COL);
//电脑下棋
ComputerMove(board, ROW, COL);
PrintBoard(board, ROW, COL);
}
}运行截图如下：
可以发现大部分的功能已经实现了，但是还不能够判断输赢。所以接下来我们进行判断输赢的实现。
5.判断输赢也有几种情况：1.玩家赢 2.电脑赢 3.平局 4.还未分出胜负，游戏继续
其中发现无论是电脑赢还是玩家赢，其判定标志都是一样的，有连续三个符号相等即可。所以也分三种情况：1.行 2.列 3.对角线。所以，可以为了方便判断谁赢，我们可以让函数的返回值做点文章。返回值可以设置为下面这种标准：
1.*--玩家赢
2.#--电脑赢
3.C--继续
4.Q--平局
这样一来既解决了输赢的情况，也能够很好的知道输赢的一方。再进行胜利条件的判断，
1.行：由于棋盘固定为3*3，所以只要遍历数组每一行的内容，如果有三个连续相等的符号而且不是空格时，表示有人胜利，直接返回其中任意一个元素即可。
2.列：与行一样，只是要循环判断的是每一列的元素是否符合。
3.对角线：3*3的棋盘只有两条对角线，只要直接对这两条对角线进行判断即可。
char IsWin(char board[ROW][COL], int row, int col) {
//行
for (int i = 0; i < row; i++) {
if (board[i][0] == board[i][1]&& board[i][1] == board[i][2]&&board[i][0]!=' ')
return board[i][0];
}
//列
for (int j = 0; j如果程序执行完上述代码仍然没有结束，说明可能是继续游戏，也可能是平局，为了区分二者，我们需要判断该棋盘是否满了，如果满了则说为平局，反之则继续游戏。为了方便，将判断是否满了的代码在封装成一个函数(可以直接写在判断胜负的函数前面，不需要在头文件里再声明了)，如果满了返回真，没满返回假。
bool isfull(char board[ROW][COL], int row, int col) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (board[i][j]== ' ')
return false;
}
}
return true;
}char IsWin(char board[ROW][COL], int row, int col) {
//行
for (int i = 0; i < row; i++) {
if (board[i][0] == board[i][1]&& board[i][1] == board[i][2]&&board[i][0]!=' ')
return board[i][0];
}
//列
for (int j = 0; j6.最后在game()函数中调用这些函数，每下一次棋都要判断一下输赢。利用ret来接受判断输赢的返回值，在对其进行判断，决定输赢。
void game() {
char ret;
char board[ROW][COL] = { 0 };
//初始化棋盘
InitBoard(board, ROW, COL);
//打印棋盘
PrintBoard(board, ROW, COL);
while (1) {
//玩家下棋
PlayerMove(board, ROW, COL);
//判断输赢
PrintBoard(board, ROW, COL);
ret = IsWin(board, ROW, COL);
if (ret != 'C')
break;
//电脑下棋
ComputerMove(board, ROW, COL);
PrintBoard(board, ROW, COL);
ret = IsWin(board, ROW, COL);
if (ret != 'C')
break;
}
if (ret == '*')
printf("恭喜你，你赢了\n");
if (ret == '#')
printf("很遗憾，你输了\n");
if (ret == 'Q')
printf("平局\n");
}最后再附上完整的代码：
1.game.h:
#pragma once
#pragma warning(disable:4996)
#include
#include
#include
#define ROW 3
#define COL 3
void InitBoard(char board[ROW][COL], int row, int col);
void PrintBoard(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); 2.game.cpp:
#include"game.h"
//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
board[i][j] = ' ';
}
}
}
//打印棋盘
void PrintBoard(char board[ROW][COL], int row, int col) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
printf(" %c ", board[i][j]);
if (j < col - 1)
printf("|");
}
printf("\n");
if (i < row - 1) {
for (int k = 0; k < col; k++) {
printf("---");
if (k < col - 1)
printf("|");
}
printf("\n");
}
}
}
//玩家下棋
void PlayerMove(char board[ROW][COL], int row, int col) {
int x = 0;
int y = 0;
printf("玩家下棋：\n");
printf("请输入您要下的坐标：\n");
while (1) {
scanf("%d%d", &x, &y);
if (x<1 || x>row || y<1 || y>col)
printf("输入的值有误,请重新输入\n");
else {
if (board[x-1][y-1] == ' ') {
board[x - 1][y - 1] = '*';
break;
}
else
printf("该位置已经被占，请到其它位置下棋\n");
}
}
}
//电脑下棋
void ComputerMove(char board[ROW][COL], int row, int col) {
int x = 0;
int y = 0;
printf("电脑下棋:\n");
while (1) {
x = rand() % row;
y = rand() % col;
if (board[x][y] == ' ') {
board[x][y] = '#';
break;
}
}
}
//判断是否满了,满了返回1，没满返回0
bool isfull(char board[ROW][COL], int row, int col) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (board[i][j]== ' ')
return false;
}
}
return true;
}
//判断输赢
//*--玩家赢
//#--电脑赢
//C--继续
//Q--平局
char IsWin(char board[ROW][COL], int row, int col) {
//行
for (int i = 0; i < row; i++) {
if (board[i][0] == board[i][1]&& board[i][1] == board[i][2]&&board[i][0]!=' ')
return board[i][0];
}
//列
for (int j = 0; j3.三子棋.cpp:
#include"game.h"
void menu() {
printf("----------------------\n");
printf("----1.play 2.exit----\n");
printf("----------------------\n");
}
void game() {
char ret;
char board[ROW][COL] = { 0 };
//初始化棋盘
InitBoard(board, ROW, COL);
//打印棋盘
PrintBoard(board, ROW, COL);
while (1) {
//玩家下棋
PlayerMove(board, ROW, COL);
//判断输赢
PrintBoard(board, ROW, COL);
ret = IsWin(board, ROW, COL);
if (ret != 'C')
break;
//电脑下棋
ComputerMove(board, ROW, COL);
PrintBoard(board, ROW, COL);
ret = IsWin(board, ROW, COL);
if (ret != 'C')
break;
}
if (ret == '*')
printf("恭喜你，你赢了\n");
if (ret == '#')
printf("很遗憾，你输了\n");
if (ret == 'Q')
printf("平局\n");
}
int main() {
int input=0;
srand((unsigned int)time(NULL));
do {
menu();
printf("请输入您的选择:\n");
scanf("%d", &input);
switch (input) {
case 1:
printf("三子棋游戏开始\n");
game();
break;
case 2:
printf("退出游戏\n");
break;
default:
printf("您输入的值有误\n");
break;
}
} while (input!=2);
return 0;
}总结：
简易的三子棋，总体设计并不算特别难，但是一步步结合起来，自己练习一遍会遇到很多的问题，同时解决完这些问题后会让自己感觉醍醐灌顶。自己慢慢敲一遍，认真体会每一处细节，相信对自己分文件编写的代码能力会有一个很大的提高。如果觉得不过瘾可以再看看下面的改进版三子棋。
改进版：
先给出运行截图：
可以发现相比简单版仅仅是增加了一个用户自主选择棋盘大小的功能，但实际在实现的过程中有很多地方的代码 都需要改进。改进具体有以下几个各方面：
1.由于数组的大小是固定的，即静态数组的大小必须是一个常量值，这就需要我们自己动态申请出一个动态二维数组。
2.由于数组大小是变化的，所以判读获胜条件时，不能够像之前那样暴力的判断了，需要更加灵活的处理。
先对问题1，进行处理：
按行为二维数组分配了内存空间。首先通过malloc函数为二维数组的行分配了内存空间（使用cahr**指针指向每一行的首地址），然后循环遍历每一行，为每一行分配了相应大小的内存空间（使用char*指针指向具体的元素），最终组成了一个size*size的二维数组。每一行的元素空间是连续分配的，可以通过双指针 board来访问和操作二维数组中的元素。
char** board = (char**)malloc(size* sizeof(char*));
for (int i = 0; i < size; i++) {
board[i] = (char*)malloc(size * sizeof(char));
}同时记得要在程序结束时，释放动态分配的内存空间，避免内存泄漏。
for (int i = 0; i 值得注意的是，由于自己创建数组的原因会导致很多函数参数出现问题，所以也要相应的将函数的形式参数进行改变。
void InitBoard(char **board, int row, int col);
void PrintBoard(char **board, int row, int col);
void PlayerMove(char **board,int row, int col);
void ComputerMove(char ** board, int row, int col);
char iswin(char** board, int row, int col);现在再对问题2进行处理：
先处理行的情况：
改进的函数使用了两层嵌套的循环来遍历整个棋盘。首先，对每一行进行检查。在外层循环中，通过变量i遍历行，内层循环中，通过变量j遍历列。
在每一行的循环中，首先需要重置计数器count为0，并将变量sign赋值为该行的第一个元素board[i][0]。计数器count用于记录连续出现的相同字符的个数，变量sign用于记录当前连续的字符。
然后，通过判断字符board[i][j]是否为空格来更新变量sign的值。如果为空格且sign不为空格，则将sign赋值为board[i][j]。这样做是为了处理第一个非空格字符。
接着，通过判断board[i][j]的值，对计数器count进行更新。如果board[i][j]为空格，则将count重置为0，并通过continue语句跳过本次循环。
如果board[i][j]不为空格，再进一步判断board[i][j]与sign的关系。如果相等，则将count加1，并更新sign的值为当前字符。
如果board[i][j]与sign不相等，则将sign的值更新为当前字符，并将count重置为0。
最后，通过判断count是否等于3来判断是否出现连续相同字符的情况。如果满足条件，则说明存在赢家，返回对应的字符。
char iswin(char** board, int row, int col) {
//行
int count = 0;
char sign = board[0][0];
for (int i = 0; i < row; i++) {
count = 0;//每一行要重置计数器
sign = board[i][0];
for (int j = 0; j < col; j++) {
if (sign ==' '&&board[i][j]!=' ') {
sign = board[i][j];
}
if (board[i][j] == ' ') {
count = 0;
continue;
}
else {
if (board[i][j] == sign) {
count++;
sign = board[i][j];
}
else {
sign = board[i][j];
count = 0;
}
if (count ==3) {
return board[i][j];
}
}
}
}
}再处理列的情况：列的情况和行类似只是将行列对换一下，这里直接给出代码：
//列
count = 0;//使用前先将计数器置零
sign = board[0][0];//标志也要重置
for (int j = 0;j处理对角线的情况：与简易版一样也要分主对角线和副对角线。
主对角线：一样通过两层嵌套的循环遍历主对角线。在外层循环中，通过变量i遍历行，内层循环中，通过变量j遍历列。循环的终止条件是i <= row - 3和j <= col - 3，这是为了保证检查的位置至少可以有3个连续的元素。在每个位置，通过判断board[i][j]与其右下角和右下第二个位置的元素是否相等，以及是否为空格，来判断是否有连续三个相同的字符。如果满足条件，则存在赢家，返回对应的字符。
副对角线：通过两层嵌套的循环遍历副对角线。在外层循环中，通过变量i遍历行，内层循环中，通过变量j遍历列。循环的终止条件是i <= row - 3和j >= 2，这是为了保证检查的位置至少可以有3个连续的元素。在每个位置，通过判断board[i][j]与其左下角和左下第二个位置的元素是否相等，以及是否为空格，来判断是否有连续三个相同的字符。如果满足条件，则存在赢家，返回对应的字符。
//对角线
// 检查主对角线
//(i, j), (i+1, j+1), (i+2, j+2),三个位置
for (int i = 0; i<=row-3; i++) {
for (int j = 0; j <= col-3; j++) {
if (board[i][j] != ' ' &&board[i][j] == board[i + 1][j + 1] &&board[i][j] ==board[i + 2][j + 2]) {
return board[i][j];
}
}
}
//副对角线
for (int i = 0; i <= row - 3; i++) {
for (int j = col - 1; j >= 2; j--) {
// 检查是否存在连续三个相等的符号：(i, j), (i+1, j-1), (i+2, j-2)
if (board[i][j] != ' ' && board[i][j] == board[i + 1][j - 1] && board[i][j] == board[i + 2][j - 2]) {
return board[i][j];
}
}
}最后再给出完整代码：
1.game.h
#pragma once
#pragma warning(disable:4996)
#include
#include
#include
void InitBoard(char **board, int row, int col);
void PrintBoard(char **board, int row, int col);
void PlayerMove(char **board,int row, int col);
void ComputerMove(char ** board, int row, int col);
char iswin(char** board, int row, int col); 2.game.cpp
#include"game.h"
//初始化棋盘
void InitBoard(char** board, int row, int col) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
board[i][j] = ' ';
}
}
}
//打印棋盘
void PrintBoard(char** board, int row, int col) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
printf(" %c ", board[i][j]);
if (j < col - 1)
printf("|");
}
printf("\n");
if (i < row - 1) {
for (int k = 0; k < col; k++) {
printf("---");
if (k < col - 1)
printf("|");
}
printf("\n");
}
}
}
//玩家下棋
void PlayerMove(char** board, int row, int col) {
int x = 0;
int y = 0;
printf("玩家下棋：\n");
printf("请输入您要下的坐标：\n");
while (1) {
scanf("%d%d", &x, &y);
if (x<1 || x>row || y<1 || y>col)
printf("输入的值有误,请重新输入\n");
else {
if (board[x-1][y-1] == ' ') {
board[x - 1][y - 1] = '*';
break;
}
else
printf("该位置已经被占，请到其它位置下棋\n");
}
}
}
//电脑下棋
void ComputerMove(char** board, int row, int col) {
int x = 0;
int y = 0;
printf("电脑下棋:\n");
while (1) {
x = rand() % row;
y = rand() % col;
if (board[x][y] == ' ') {
board[x][y] = '#';
break;
}
}
}
//判断是否满了,满了返回1，没满返回0
int isfull(char** board, int row, int col) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (board[i][j]== ' ')
return 0;
}
}
return 1;
}
//判断输赢
//*--玩家赢
//#--电脑赢
//C--继续
//Q--平局
char iswin(char** board, int row, int col) {
//行
int count = 0;
char sign = board[0][0];
for (int i = 0; i < row; i++) {
count = 0;//每一行要重置计数器
sign = board[i][0];
for (int j = 0; j < col; j++) {
if (sign ==' '&&board[i][j]!=' ') {
sign = board[i][j];
}
if (board[i][j] == ' ') {
count = 0;
continue;
}
else {
if (board[i][j] == sign) {
count++;
sign = board[i][j];
}
else {
sign = board[i][j];
count = 0;
}
if (count ==3) {
return board[i][j];
}
}
}
}
//列
count = 0;//使用前先将计数器置零
sign = board[0][0];//标志也要重置
for (int j = 0;j= 2; j--) {
// 检查是否存在连续三个相等的符号：(i, j), (i+1, j-1), (i+2, j-2)
if (board[i][j] != ' ' && board[i][j] == board[i + 1][j - 1] && board[i][j] == board[i + 2][j - 2]) {
return board[i][j];
}
}
}
//平局
if (isfull(board, row, col))
return 'Q';
//继续
return 'C';
} 3.三子棋.cpp
#include"game.h"
void menu() {
printf("----------------------\n");
printf("----1.play 2.exit----\n");
printf("----------------------\n");
}
void game() {
int size = 0;
printf("请输入棋盘大小\n");
scanf("%d", &size);
if(size < 3) {
printf("棋盘大小至少为3*3，请重新输入\n");
while (size<3) {
printf("请输入棋盘大小\n");
scanf("%d", &size);
if (size < 3)
printf("棋盘大小至少为3*3，请重新输入\n");
}
}
char ret;
char** board = (char**)malloc(size* sizeof(char*));
for (int i = 0; i < size; i++) {
board[i] = (char*)malloc(size * sizeof(char));
}
//初始化棋盘
InitBoard(board, size, size);
//打印棋盘
PrintBoard(board, size, size);
while (1) {
//玩家下棋
PlayerMove(board, size, size);
PrintBoard(board, size, size);
//判断输赢
ret = iswin(board, size, size);
if (ret != 'C')
break;
//电脑下棋
ComputerMove(board, size, size);
PrintBoard(board, size, size);
ret = iswin(board, size, size);
if (ret != 'C')
break;
}
if (ret == '*')
printf("恭喜你，你赢了\n");
if (ret == '#')
printf("很遗憾，你输了\n");
if (ret == 'Q')
printf("平局\n");
for (int i = 0; i 总结：
改进版的三子棋比原来要完善了很多，虽然看似功能只是一个小小的增加，但其实背后的很多算法都截然不同。改进版的三子棋很明显要更贴切实际，当然这个代码仍然还有很多可以修正的地方，比如可以让电脑下棋更加智能化，也可以设计成两人联网对战。由于个人实力有限，感兴趣的小伙伴可以自己钻研，将剩下的部分完成。我相信完整的将代码敲下来，肯定也是收获满满的。