C语言工程实践实现完整的五子棋项目四（最终章）

于 2024-08-25 16:03:33 发布
阅读量560 收藏 11
点赞数 11
文章标签： c语言 开发语言 visual studio git 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_86557724/article/details/141528530
版权

五子棋第四章

人机对战部分和文件存储部分

五子棋

前言

本篇文章为完整工程实践五子棋项目的第四章。
如未看过前面的章节：
五子棋第一章
五子棋第二章
五子棋第三章
本篇文章是五子棋项目的最后一章，我们将讲解五子棋人机对战部分和文件存储部分的具体实现。

一、大致思路

我们在实现五子棋人机对战部分之前首先需要有一个大的方向即大致思路，这里我运用到的方法是计算权重法。所以权重，说得通俗易懂一点就是重要性，我们可以通过判断每个空位置附近的棋子分布状况，然后给不同的情况按重要程度分配不同的权重值，最后我们再选出权重值最大的位置让电脑进行下棋，这就是计算权重法的大致思路。

二、头文件部分

game.h

#include<windows.h>

#define X 16
#define Y 16

typedef struct player
{
	char account[15];
	char password[15];
	char id[10];
	int win;
	int lose;
	int tie;
	int score;
	struct player* prev;
	struct player* next;
}player;

typedef struct chess
{
	int x;
	int y;
	double weight;
}chess;

void gameprocess(player* p, player* q);
void init(char board[X][Y], int x, int y);
void print(char board[X][Y], int x, int y);
int play1(char board[X][Y], int x, int y);
int play2(char board[X][Y], int x, int y);
int judge(char board[X][Y], int x, int y, int a, int b);
void computerprocess(player* p);
int computer(char board[X][Y], int x, int y, char my);
chess* findmax(chess* pch, int n);
double cale(char board[X][Y], int x, int y, const int a, const int b, char my);
void calesum(double* psum, int n, int m, int t, int k, int d, int h);

由于我们人机部分对战的实现还是属于游戏内容部分的内容，所以我们在这里就将人机对战部分的相关函数声明放在之前的game.h中，此外我们还多定义了一个名为chess的结构体，其中x，y用来代表一个具体位置，weight用来代表该位置的权重值。顺带一提，我们编写人机对战部分的时候建议新建一个computer.c的源文件进行编写，避免game.h的文件过大且不利于我们进行文件的管理。

三、人机对战部分

1.游戏进程

computerprocess(player* p)函数

void computerprocess(player* p)
{
	srand((unsigned int)time(NULL));
	int r = rand();
	if (r % 2 == 0)
	{
		printf("玩家%s先手\n", p->id);
		Sleep(3000);
		char board[X][Y] = { 0 };
		init(board, X, Y);
		print(board, X, Y);
		while (1)
		{
			int sum = 0;
			printf("轮到%s玩家(*)下棋\n", p->id);
			int ret1 = play1(board, X, Y);
			if (ret1 == 1)
			{
				print(board, X, Y);
				printf("\n");
				printf("恭喜玩家%s获胜\n", p->id);
				printf("\n");
				Sleep(5000);
				break;
			}
			sum++;
			if (sum == 113)
			{
				printf("平局\n");
				print(board, X, Y);
				printf("\n");
				Sleep(5000);
				break;
			}
			print(board, X, Y);
			printf("轮到电脑(#)下棋\n");
			Sleep(2000);
			int  ret2 = computer(board, X, Y, '#');
			if (ret2 == 2)
			{
				print(board, X, Y);
				printf("\n");
				printf("恭喜电脑获胜\n");
				printf("\n");
				Sleep(5000);
				break;
			}
			print(board, X, Y);
		}
	}
	else
	{
		printf("电脑先手\n");
		Sleep(3000);
		char board[X][Y] = { 0 };
		init(board, X, Y);
		print(board, X, Y);
		while (1)
		{
			int sum = 0;
			printf("轮到电脑(*)下棋\n");
			Sleep(2000);
			int  ret1 = computer(board, X, Y, '*');
			if (ret1 == 1)
			{
				print(board, X, Y);
				printf("\n");
				printf("恭喜电脑获胜\n");
				printf("\n");
				Sleep(5000);
				break;
			}
			sum++;
			if (sum == 113)
			{
				printf("平局\n");
				print(board, X, Y);
				printf("\n");
				Sleep(5000);
				break;
			}
			print(board, X, Y);
			printf("轮到%s玩家(#)下棋\n", p->id);
			int ret2 = play2(board, X, Y);
			if (ret2 == 2)
			{
				print(board, X, Y);
				printf("\n");
				printf("恭喜玩家%s获胜\n", p->id);
				printf("\n");
				Sleep(5000);
				break;
			}
			print(board, X, Y);
		}
	}

}

这个函数用来控制游戏的总体进程，传入的变量p代表当前登录的玩家。这个函数和我们之前在玩家对战部分实现的gameprocess(player* p,player* q)函数类似。先用随机数随机确定玩家是先手还是后手，然后用死循环控制游戏持续进行，直到有一方获胜或者平局才跳出该死循环，结束游戏。

2.电脑下棋逻辑

computer(char board[X][Y], int x, int y, char my)函数

int computer(char board[X][Y], int x, int y, char my)
{
	chess ch[225] = { 0 };
	int n = 0;
	int i = 0;
	for (i = 1; i < x; i++)
	{
		int j = 0;
		for (j = 1; j < y; j++)
		{
			if (board[i][j] == ' ')
			{
				ch[n].x = i;
				ch[n].y = j;
				ch[n].weight = cale(board, X, Y, i, j, my);
				n++;
			}
		}
	}
	chess* max = findmax(ch, n);
	board[max->x][max->y] = my;
	printf("电脑下棋坐标:(%d,%d)\n", max->x, max->y);
	int ret = judge(board, X, Y, max->x, max->y);
	return ret;
}

这个函数用来控制电脑下棋的总体思路，即我们的计算权重法的总体思路。我们通过遍历整个棋盘，然后调用cale(board, X, Y, i, j, my)函数计算每个空位置的权重，放入名为ch的结构体数组中，之后调用findmax(ch, n)函数寻找数组中的权重值最大的位置。

3.寻找权重值最大的位置

findmax(chess* pch, int n)函数

//寻找权重最大的位置
chess* findmax(chess* pch, int n)
{
	//判断指针是否为空
	assert(pch);
	//初始化随机数
	srand((unsigned int)time(NULL));
	//生成随机数
	int r = rand();
	int sum = 0;
	chess* max = &pch[0];//假定权重最大位置
	int i = 0;
	//遍历寻找到权重最大的一个位置
	for (i = 1; i < n; i++)
	{
		if (max->weight < pch[i].weight)
		{
			max = &pch[i];
		}
	}
	chess* maxarr[225] = { 0 };//初始化权重最大位置的数组
	//遍历寻找到所有权重最大的位置
	for (i = 0; i < n; i++)
	{
		if (max->weight == pch[i].weight)
		{
			maxarr[sum] = &pch[i];//将所有权重最大的位置存储在一个数组中
			sum++;//统计权重最大的位置的个数
		}
	}
	max = maxarr[r % sum];//用随机数%上统计出的权重最大的位置个数sum，从而在最大权重的数组中随机获得一个位置
	return max;
}

这个函数用来寻找权重值最大的位置并将其返回，由于这个函数里面注释写得比较多，所以我就不再多加赘述了。

4.计算权重值逻辑

cale(char board[X][Y], int x, int y, const int a, const int b, char my)函数

double cale(char board[X][Y], int x, int y, const int a, const int b, char my)
{
	char you = 77 - my;
	double sum = 0;
	//heng
	while (1)
	{
		int n = 0;
		int m = 0;
		int t = 0;
		int i = a - 1;
		if (i >= 1)
		{
			if (board[i][b] == you)
			{
				while (i >= 1)
				{
					if (board[i][b] == you)
					{
						n++;
						i--;
					}
					else
					{
						if (board[i][b] == my)
						{
							t = 1;
						}
						else if (board[i][b] == ' ')
						{
							t = 2;
						}
						break;
					}
				}
			}
			else if (board[i][b] == my)
			{
				while (i >= 1)
				{
					if (board[i][b] == my)
					{
						m++;
						i--;
					}
					else
					{
						if (board[i][b] == you)
						{
							t = 1;
						}
						else if (board[i][b] == ' ')
						{
							t = 2;
						}
						break;
					}
				}
			}
			else if (board[i][b] == ' ')
			{
				t = 2;
			}
		}
		int k = 0;
		int d = 0;
		int h = 0;
		i = a + 1;
		if (i < x)
		{
			if (board[i][b] == you)
			{
				while (i < x)
				{
					if (board[i][b] == you)
					{
						k++;
						i++;
					}
					else
					{
						if (board[i][b] == my)
						{
							h = 1;
						}
						else if (board[i][b] == ' ')
						{
							h = 2;
						}
						break;
					}
				}

			}
			else if (board[i][b] == my)
			{
				while (i < x)
				{
					if (board[i][b] == my)
					{
						d++;
						i++;
					}
					else
					{
						if (board[i][b] == you)
						{
							h = 1;
						}
						else if (board[i][b] == ' ')
						{
							h = 2;
						}
						break;
					}
				}
			}
			else if (board[i][b] == ' ')
			{
				h = 2;
			}
		}
		calesum(&sum, n, m, t, k, d, h);
		break;
	}
	//shu
	while (1)
	{
		int n = 0;
		int m = 0;
		int t = 0;
		int j = b - 1;
		if (j >= 1)
		{
			if (board[a][j] == you)
			{
				while (j >= 1)
				{
					if (board[a][j] == you)
					{
						n++;
						j--;
					}
					else
					{
						if (board[a][j] == my)
						{
							t = 1;
						}
						else if (board[a][j] == ' ')
						{
							t = 2;
						}
						break;
					}
				}
			}
			else if (board[a][j] == my)
			{
				while (j >= 1)
				{
					if (board[a][j] == my)
					{
						m++;
						j--;
					}
					else
					{
						if (board[a][j] == you)
						{
							t = 1;
						}
						else if (board[a][j] == ' ')
						{
							t = 2;
						}
						break;
					}
				}
			}
			else if (board[a][j] == ' ')
			{
				t = 2;
			}
		}
		int k = 0;
		int d = 0;
		int h = 0;
		j = b + 1;
		if (j < y)
		{
			if (board[a][j] == you)
			{
				while (j < y)
				{
					if (board[a][j] == you)
					{
						k++;
						j++;
					}
					else
					{
						if (board[a][j] == my)
						{
							h = 1;
						}
						else if (board[a][j] == ' ')
						{
							h = 2;
						}
						break;
					}
				}
			}
			else if (board[a][j] == my)
			{
				while (j < y)
				{
					if (board[a][j] == my)
					{
						d++;
						j++;
					}
					else
					{
						if (board[a][j] == you)
						{
							h = 1;
						}
						else if (board[a][j] == ' ')
						{
							h = 2;
						}
						break;
					}
				}
			}
			else if (board[a][j] == ' ')
			{
				h = 2;
			}
		}
		calesum(&sum, n, m, t, k, d, h);
		break;
	}
	//xie1
	while (1)
	{
		int n = 0;
		int m = 0;
		int t = 0;
		int i = a - 1;
		int j = b - 1;
		if (i >= 1 && j >= 1)
		{
			if (board[i][j] == you)
			{
				while (i >= 1 && j >= 1)
				{
					if (board[i][j] == you)
					{
						n++;
						i--;
						j--;
					}
					else
					{
						if (board[i][j] == my)
						{
							t = 1;
						}
						else if (board[i][j] == ' ')
						{
							t = 2;
						}
						break;
					}
				}
			}
			else if (board[i][j] == my)
			{
				while (i >= 1 && j >= 1)
				{
					if (board[i][j] == my)
					{
						m++;
						i--;
						j--;
					}
					else
					{
						if (board[i][j] == you)
						{
							t = 1;
						}
						else if (board[i][j] == ' ')
						{
							t = 2;
						}
						break;
					}
				}
			}
			else if (board[i][j] == ' ')
			{
				t = 2;
			}
		}
		int k = 0;
		int d = 0;
		int h = 0;
		i = a + 1;
		j = b + 1;
		if (i < x && j < y)
		{
			if (board[i][j] == you)
			{
				while (i < x && j < y)
				{
					if (board[i][j] == you)
					{
						k++;
						i++;
						j++;
					}
					else
					{
						if (board[i][j] == my)
						{
							h = 1;
						}
						else if (board[i][j] == ' ')
						{
							h = 2;
						}
						break;
					}
				}
			}
			else if (board[i][j] == my)
			{
				while (i < x && j < y)
				{
					if (board[i][j] == my)
					{
						d++;
						i++;
						j++;
					}
					else
					{
						if (board[i][j] == you)
						{
							h = 1;
						}
						else if (board[i][j] == ' ')
						{
							h = 2;
						}
						break;
					}
				}
			}
			else if (board[i][j] == ' ')
			{
				h = 2;
			}
		}
		calesum(&sum, n, m, t, k, d, h);
		break;
	}
	//xie2
	while (1)
	{
		int n = 0;
		int m = 0;
		int t = 0;
		int i = a - 1;
		int j = b + 1;
		if (i >= 1 && j < y)
		{
			if (board[i][j] == you)
			{
				while (i >= 1 && j < y)
				{
					if (board[i][j] == you)
					{
						n++;
						i--;
						j++;
					}
					else
					{
						if (board[i][j] == my)
						{
							t = 1;
						}
						else if (board[i][j] == ' ')
						{
							t = 2;
						}
						break;
					}
				}
			}
			else if (board[i][j] == my)
			{
				while (i >= 1 && j < y)
				{
					if (board[i][j] == my)
					{
						m++;
						i--;
						j++;
					}
					else
					{
						if (board[i][j] == you)
						{
							t = 1;
						}
						else if (board[i][j] == ' ')
						{
							t = 2;
						}
						break;
					}
				}
			}
			else if (board[i][j] == ' ')
			{
				t = 2;
			}
		}
		int k = 0;
		int d = 0;
		int h = 0;
		i = a + 1;
		j = b - 1;
		if (i < x && j >= 1)
		{
			if (board[i][j] == you)
			{
				while (i < x && j >= 1)
				{
					if (board[i][j] == you)
					{
						k++;
						i++;
						j--;
					}
					else
					{
						if (board[i][j] == my)
						{
							h = 1;
						}
						else if (board[i][j] == ' ')
						{
							h = 2;
						}
						break;
					}
				}
			}
			else if (board[i][j] == my)
			{
				while (i < x && j >= 1)
				{
					if (board[i][j] == my)
					{
						d++;
						i++;
						j--;
					}
					else
					{
						if (board[i][j] == you)
						{
							h = 1;
						}
						else if (board[i][j] == ' ')
						{
							h = 2;
						}
						break;
					}
				}
			}
			else if (board[i][j] == ' ')
			{
				h = 2;
			}
		}
		calesum(&sum, n, m, t, k, d, h);
		break;
	}
	return sum;
}

这个函数用来判断每个空位置周围的棋子分布状况并返回相应的权重值，这个也是人机对战实现部分中最核心的一个函数。和之前的judge函数类似，我们分别用循环对四个方向进行判断，所以在这里我就只讲解一个方向的代码。

while (1)
	{
		int n = 0;//you棋子的数量
		int m = 0;//my棋子的数量
		int t = 0;//标记结束时的状态，即对方的棋子或空位置或墙
		int i = a - 1;
		if (i >= 1)
		{
			if (board[i][b] == you)
			{
				while (i >= 1)
				{
					if (board[i][b] == you)
					{
						n++;
						i--;
					}
					else
					{
						if (board[i][b] == my)
						{
							t = 1;
						}
						else if (board[i][b] == ' ')
						{
							t = 2;
						}
						break;
					}
				}
			}
			else if (board[i][b] == my)
			{
				while (i >= 1)
				{
					if (board[i][b] == my)
					{
						m++;
						i--;
					}
					else
					{
						if (board[i][b] == you)
						{
							t = 1;
						}
						else if (board[i][b] == ' ')
						{
							t = 2;
						}
						break;
					}
				}
			}
			else if (board[i][b] == ' ')
			{
				t = 2;
			}
		}
		int k = 0;
		int d = 0;
		int h = 0;
		i = a + 1;
		if (i < x)
		{
			if (board[i][b] == you)
			{
				while (i < x)
				{
					if (board[i][b] == you)
					{
						k++;
						i++;
					}
					else
					{
						if (board[i][b] == my)
						{
							h = 1;
						}
						else if (board[i][b] == ' ')
						{
							h = 2;
						}
						break;
					}
				}

			}
			else if (board[i][b] == my)
			{
				while (i < x)
				{
					if (board[i][b] == my)
					{
						d++;
						i++;
					}
					else
					{
						if (board[i][b] == you)
						{
							h = 1;
						}
						else if (board[i][b] == ' ')
						{
							h = 2;
						}
						break;
					}
				}
			}
			else if (board[i][b] == ' ')
			{
				h = 2;
			}
		}
		calesum(&sum, n, m, t, k, d, h);
		break;
	}

这段代码是判断水平方向的棋子分布情况。我们在判断每个方向的棋子分布情况时也要分为两边来看。这个代码的第一部分即是判断水平方向的左边的棋子分布情况。n代表you棋子（对方棋子）的数量；m代表my棋子（己方棋子）的数量；t标记结束时的状态，即对方的棋子或空位置或墙（0为墙，1为对方棋子，2为空位置）。而后对水平方向的右边的棋子分布状态的判断与之类似。k，d，h也依次对应前面的n，m，t。当我们把水平方向的两边的状态都判断完成后，我们就可以调用calesum(&sum, n, m, t, k, d, h)函数来对权重进行赋值。我们在这里使用的是sum代表权重值，由于我们要计算四个方向的权重值，所以我们要传sum的地址，这样才能在calesum函数里面改变sum的值。然后当四个方向的权重值都计算完后，我们就将sum作为返回值返回。

5.具体赋值操作

calesum(double* psum, int n, int m, int t, int k, int d, int h)函数

void calesum(double* psum, int n, int m, int t, int k, int d, int h)
{
	if (m + d >= 4)
	{
		*psum = *psum + 10000000;
	}
	else if (n + k >= 4)
	{
		*psum = *psum + 1000000;
	}
	else if (m + d == 3 && t == 2 && h == 2)
	{
		*psum = *psum + 100000;
	}
	else if (n + k == 3 && t == 2 && h == 2)
	{
		*psum = *psum + 10000;
	}
	else if (m + d == 3 && (t == 2 || h == 2))
	{
		*psum = *psum + 50;
	}
	else if (n + k == 3 && (t == 2 || h == 2))
	{
		*psum = *psum + 50;
	}
	else if (m + d == 2 && t == 2 && h == 2)
	{
		*psum = *psum + 150;
	}
	else if (n + k == 2 && t == 2 && h == 2)
	{
		*psum = *psum + 100;
	}
	else if (m + d == 2 && (t == 2 || h == 2))
	{
		*psum = *psum + 25;
	}
	else if (n + k == 2 && (t == 2 || h == 2))
	{
		*psum = *psum + 25;
	}
	else if (m + d == 1 && t == 2 && h == 2)
	{
		*psum = *psum + 75;
	}
	else if (n + k == 1 && t == 2 && h == 2)
	{
		*psum = *psum + 50;
	}
	if (t == 0 || h == 0)
	{
		*psum = *psum - 25;
	}
}

这个函数就是进行具体赋权重值的操作。我们根据不同的棋子的分布情况给予不同的权重值。如m + d >= 4，即代表这个位置附近已经有自己的棋子大于或等于4颗，即我们下在这里就一定会赢，所以我们权重值给的最大；又比如m + d == 3 && t == 2 && h == 2，代表这个位置附近已经有3颗自己的棋子，并且两边都为空，我们下在这里就能实现四颗连子，所以这种情况的权重也比较高。依次类推，我们将每种情况给与不同的权重。这里权重值的具体数字并不固定，我们可以进行一定地调整来改变人机的智慧程度，甚至可以运用概率的知识给出更加合理的值。不过其实就使用我这里给出的赋值，你想要下赢这个人机都还是有一定难度的。毕竟人可能会眼瞎，但电脑可不会。

6.人机对战成果

在这里插入图片描述
在这里插入图片描述

四、文件存储部分

既然是一个完整的工程实践项目，我们就还需要实现最后一部分–文件存储部分。文件存储部分的逻辑其实比较简单，就是在程序运行的开始后进行读取文件信息，然后在程序结束前进行写入文件信息的操作。这里需要说明一下的是，程序运行开始后指的是运行完ListInit()初始化函数之后，程序程序前指的是运行destory(&head)释放空间函数之前。其余逻辑，只要我们熟练掌握文件读写相关的库函数的使用即可实现。文件读写部分其实只需记住一句话，怎么写进去的就怎么读出来。

load(player* head, int* num)函数，实现读取文件信息操作的函数。

void load(player* head, int* num)
{
	assert(head);
	FILE* fp = fopen("五子棋.txt", "rb");
	if (fp == NULL)
	{
		perror("load");
		return;
	}
	player t = { 0 };
	while (fread(&t, sizeof(player), 1, fp) == 1)
	{
		player* pnew = (player*)malloc(sizeof(player));
		if (pnew == NULL)
		{
			perror("malloc");
			exit(-1);
		}
		*pnew = t;
		player* next = head->next;
		head->next = pnew;
		pnew->prev = head;
		pnew->next = next;
		next->prev = pnew;
		(*num)++;
	}
	fclose(fp);
	fp = NULL;
}

save(player* head)函数，实现写入文件信息操作的函数。

void save(player* head)
{
	assert(head);
	FILE* fp = fopen("五子棋.txt", "wb");
	if (fp == NULL)
	{
		perror("save");
		return;
	}
	player* cur = head->next;
	while (cur != head)
	{
		fwrite(cur, sizeof(player), 1, fp);
		cur = cur->next;
	}
	fclose(fp);
	fp = NULL;
}

总结

本次五子棋项目的第四章就先到这里了，这也是这个工程实践项目的最后一章了。到这里我们的这个完整的五子棋项目就算彻底实现好了。如果我们能完成的实现这个项目，我相信收获一定会很多，我们的C语言水平也一定能提高一个档次。

如需源码，可在我的gitee上找到，下面是链接。
五子棋源码

如对您有所帮助，可以来个三连，感谢大家的支持。

每文推荐

司南–奔赴
陈奕迅—不要说话
林俊杰–茉莉雨

学技术学累了时可以听歌放松一下。

蓝风破云
关注
  • 11
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【ChatGPT】实用 Prompt 指令大全 —— 一文教你如何更好地挖掘 GPT 的价值
禅与计算机程序设计艺术
04-15 2万+
ChatGPT 是由 OpenAI 开发的一种先进的大型语言生成模型，能够理解和生成准确、自然且连贯的文本。文本生成数据分析内容审核语义理解自然语言推理以及其他众多任务ChatGPT是一种基于GPT-3.5架构的大型语言模型，由OpenAI公司开发。该模型在自然语言处理领域有着广泛的应用，可以用于文本生成、文本分类、情感分析、问答系统等任务。本文将从模型的架构、训练方式、优缺点等方面对ChatGPT进行详细介绍。一、模型架构。
软件工程实践寒假作业
ok1547202814的博客
02-11 1581
同时，要注重全面发展，包括技术能力和软技能的提升。在大学课堂上，你可能会看到好多人都在忙自己的事，但这不是你不听课的理由，有些人上课不听是因为自己已经提前学过并且做了很多练习的，不能有从众心理，毕竟做什么有人领路都是好的，听课也是如此，你可以通过听课来了解很多知识，对于老师没有细讲的部分，可以课下自己学习，来补充知识。在进入大学之前，我一直以为跟随课堂教学就能学习很多开发所需的知识，但是随着课程的推进，我逐渐意识到，学校里教的东西都只是基础，是用来引导你的，更多的还要靠自学，去提高自己的技术力。
C语言程序设计课程设计题目[2023-02-11]
程序设计
02-11 4492
C语言程序设计课程设计题目选题说明：1、以下题目有部分可能功能相近，请同学们可从不同的角度来分析实现。2、题目描述和要求仅供参考，同学们可以查找资料，自行完成分析、确定功能，但功能不得少于题目的描述和要求。3、每人选一个课题，同一个行政班级内不得重复，由班长或学习委员统一协调。4、所有程序必须用C语言实现，否则成绩按不及格计。5、最终提交的程序源代码不得少于200行（不得以注释语句，重复书写函数等来恶意凑代码），如果因这些原因导致代码不能评分，课程设计直接按不及格计。
java五子棋实验总结与心得_实验总结与心得体会
weixin_42114046的博客
02-27 3352
实验总结与心得体会　　实验总结与心得体会之前我在编程的过程中写过一份实验总结，里面详细的记录了实验中遇到的各种问题以及解决办法，当我完成了整个实验整理文档的时候，看到程序说明文档的后面标着0kB，心里一下子就忐忑起来了，打开文档，果然，0KB，什么也没有了。当初编写程序之前，面对着完全不熟悉的C++，就好像是面对着一座小山，当我一点一点的把它啃下来了，再看这些程序的时候，也不觉得有多少内容了，期间...
android安卓源码海量项目合集打包-1
热门推荐
chenhao0568的专栏
06-11 13万+
下载地址 最后更新共计113个分类5177套源码29.2 GB。 卷 新加卷 的文件夹 PATH 列表 卷序列号为 00000200 5E7A:7F30 F:. ├─前台界面 │ ├─3D标签云卡片热门 │ │ Android TagCloudView云标签的灵活运用.rar │ │ Android 实现 标签 拖动 改变位置.rar │ │ android 流式布局和热门标签.zip │ │ ...
基于C语言实现五子棋游戏完整实例代码
12-31
本文实例讲述了基于C语言实现五子棋游戏的方法，代码备有比较完整的注释，可以帮助读者更好的加以理解。 五子棋游戏代码如下： /* * 使用键盘的上下左右键移动棋盘，空格键表示下棋，ESC键退出程序 */ #include ...
纯C语言实现五子棋
09-03
《纯C语言实现五子棋》 五子棋是一种经典的双人策略游戏，深受玩家喜爱。这篇文章将介绍如何使用C语言编写一个简单的五子棋程序。尽管它没有华丽的图形用户界面，但基础的逻辑实现对于理解C语言编程以及游戏算法...
基于c语言实现的五子棋源码
最新发布
05-11
【基于C语言实现的五子棋源码】是一款适合初学者和进阶学习者研究的项目，它将经典的五子棋游戏与C语言编程技术相结合，提供了深入理解基础编程概念和算法实现的机会。通过分析这个项目，我们可以学习到以下几个关键...
图书管理系统c语言实现的项目源代码.zip
05-09
图书管理系统c语言实现的项目源代码.zip图书管理系统c语言实现的项目源代码.zip图书管理系统c语言实现的项目源代码.zip图书管理系统c语言实现的项目源代码.zip图书管理系统c语言实现的项目源代码.zip图书管理系统...
C语言实现简单五子棋小游戏
08-24
C语言实现简单五子棋小游戏 C语言是计算机编程语言之一，广泛应用于编程领域。五子棋是一种传统的棋类游戏，具有很高的娱乐性和教育性。在本文中，我们将详细介绍如何使用C语言实现简单的五子棋小游戏。 1. 棋盘的...
C语言实现五子棋小游戏
01-20
首先我们先来看一个稍微简单些的实现方式： #include #include #define N 15 int chessboard[N + 1][N + 1] = { 0 }; int whoseTurn = 0; void initGame(void); void printChessboard(void); void playChess(void...
C语言实现的简单五子棋游戏.zip
08-17
在本项目中，我们讨论的是一个使用C语言编写的简单五子棋游戏，该游戏是在Visual Studio 2013环境下开发的，并且依赖于easyX图形库来实现游戏的可视化界面。首先，让我们深入了解C语言和五子棋游戏的基本概念。 ...
c语言c++项目源代码_c语言五子棋源码.rar
03-27
C语言五子棋源码是一个集趣味性与技术性于一体的中小型C语言项目。该项目通过简洁高效的代码实现了一个具有人机对战功能的五子棋游戏。对于初学者来说，它是一个很好的实践和学习资源，可以帮助他们熟悉C语言的基本...
c语言c++项目小游戏五子棋源码带讲解视频
05-18
c语言c++项目小游戏五子棋源码带讲解视频c语言c++项目小游戏五子棋源码带讲解视频c语言c++项目小游戏五子棋源码带讲解视频c语言c++项目小游戏五子棋源码带讲解视频c语言c++项目小游戏五子棋源码带讲解视频c语言c++...
五子棋的c语言实现
07-12
本代码主要功能是用c语言实现五子棋，能够在vc6.0下完整的运行。
C语言五子棋C语言五子棋
03-25
五子棋c语言C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋...
五子棋（C语言）_C语言_五子棋_
10-03
在本项目中，我们探讨的是如何使用C语言来实现一个简单的五子棋游戏。C语言是一种基础且强大的编程语言，适合开发系统级程序和小型应用，包括游戏。五子棋，又称连珠，是一种两人对弈的策略型棋类游戏，目标是先形成...
C语言实现简易五子棋
12-16
本文实例为大家分享了C语言实现简易五子棋的具体代码，供大家参考，具体内容如下 #define _CRT_SECURE_NO_WARNINGS #include #include #include #define ROW 5 #define COL 5 char g_broad[ROW][COL]; void menu();...
基于C语言实现的五子棋游戏【100012930】
07-14
（1） 棋盘界面的显示：要求标准的规格为 15×15 五子棋棋盘（图 1-1）。 （2） 三种对弈模式：能够实现计算机与人、人与计算机、人与人三种对弈模式。此程序我只负责人-机对战部分（对 AI 落子的程序设定的合理性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值