C语言第十一课：优化井字棋游戏

已于 2022-12-14 18:04:58 修改
阅读量960 收藏 5
点赞数 18
分类专栏： C语言学习 文章标签： 游戏
于 2022-11-17 19:53:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59392935/article/details/127904387
版权

目录

前言：

一、优手着棋判定：

        1.防守型着棋优化：

        2.进攻型着棋优化：

二、界面格式优化：

        1.Sleep休眠语句：

        2.system语句：

三、优化后最终全部代码：

        1.头文件game.h:

        2.函数功能文件game.h：

        3.程序主体文件test.c：

四、总结：

前言：

        在上一篇文章中，我和各位小伙伴们一起，通过使用我们前面学习的C语言知识，编写出了一个基础版的井字棋游戏。不过我们也发现，作为基础版的井字棋游戏，它存在着很多缺陷，而在本文中，我们将要对基础版井字棋进行着棋、界面两个方面的优化。

一、优手着棋判定：

        1.防守型着棋优化：

        对于一个程序的优化，首先我们应当对其功能缺陷进行优化，而在基础版井字棋中，最大的功能缺陷便是电脑在进行着棋时，没有进行着棋优手判定，在玩家着棋后不会对玩家的进攻性着棋进行围堵，于是这里的优化便是要尝试解决这个问题。

        电脑着棋的优化，主要在于其着棋时应当对当前场上的局势进行判断，倘若在玩家横向、纵向、斜向三个方向上出现两子连子，且第三个位置上仍为空时，就应当在第三个空位上进行着棋以实现对玩家的拦截。

        原理大致了解之后，我们来研究一下具体情况的实现。首先判定应当分为三个方向，即横向，纵向与斜向。而在每个方向上，根据规则连成三子即为胜利可以得出，当下一步即将出现胜利情况时，就应当进行阻止。

        以横向为例，会出现三种情况，即在一行中前两个位置相同而第三个位置空缺，此时应当着棋于位置三；第二种情况是在一行中后两个位置相同而首位置空缺，此时应当着棋于位置一；第三种情况为一三位置相同而中间位置空缺，此时则应当着棋于中间位置。

        则纵向与斜向原理也相同。根据我们整理出来的拦截原理，我们可以轻松地写出优手拦截的程序代码：

{
	int i = 0;
	//遍历行优手判断：
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][0] == '*' && board[i][2] == ' ')
		{
			board[i][2] = 'O';
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == '*' && board[i][0] == ' ')
		{
			board[i][0] = 'O';
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][0] == '*' && board[i][1] == ' ')
		{
			board[i][1] = 'O';
			return 1;
		}
	}
	//遍历列优手判断：
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[0][i] == '*' && board[2][i] == ' ')
		{
			board[2][i] = 'O';
			return 1;
		}
		if (board[1][i] == board[2][i] && board[1][i] == '*' && board[0][i] == ' ')
		{
			board[0][i] = 'O';
			return 1;
		}
		if (board[0][i] == board[2][i] && board[0][i] == '*' && board[1][i] == ' ')
		{
			board[1][i] = 'O';
			return 1;
		}
	}
	//右斜对角线优手判断：
	if (board[0][0] == board[1][1] && board[0][0] == '*' && board[2][2] == ' ')
	{
		board[2][2] = 'O';
		return 1;
	}
	if (board[0][0] == board[2][2] && board[0][0] == '*' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][2] && board[1][1] == '*' && board[0][0] == ' ')
	{
		board[0][0] = 'O';
		return 1;
	}
	//左斜对角线优手判断：
	if (board[0][2] == board[1][1] && board[0][2] == '*' && board[2][0] == ' ')
	{
		board[2][0] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][0] && board[1][1] == '*' && board[0][2] == ' ')
	{
		board[0][2] = 'O';
		return 1;
	}
	if (board[0][2] == board[2][0] && board[0][2] == '*' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	return 0;
}

        如此，优手判断模块就完成了，接着我们只需要让电脑在着棋时进行判断，若是符合优手的着棋便进行优手着棋，若没有出现需要拦截的情况，再根据我们之前定义的随机值确定着棋坐标：

void computer_move(char board[ROW][COL], int row, int col)
{
	printf("电脑正在着棋！\n");
	if (computer_better_move(board, row, col))
	{
		;
	}
	else
	{
		while (1)
		{
			int x = rand() % row;
			int y = rand() % col;
			if (board[x][y] == ' ')
			{
				board[x][y] = 'O';
				break;
			}
		}
	}
}

        这里的执行逻辑是，if 语句的判断条件为函数“ 优手判断的返回值 ”。在优手判断函数中，若符合优手着棋的条件，便进行优手着棋，同时返回值为1，此时电脑着棋函数中的if语句判断为真，随机着棋便不再进行；若局面情况均不符合优手着棋情况，不进行优手着棋则右手判断函数返回值为0，电脑着棋函数中if语句判断为假，执行随机着棋操作。

        2.进攻型着棋优化：

        以上即为井字棋游戏的防守型着棋优化。我们还可以对电脑的进攻进行优化，即在进行防守判断前先进行判断，若电脑方已有连字或隔子，即拥有直接获胜条件时，走出进攻型着棋。

        原理很简单且与防守相同，不过这次的着棋优化判断对象为电脑自己的着棋，只需对防守着棋优化稍加改动即可：

int computer_Better_move(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][0] == 'O' && board[i][2] == ' ')
		{
			board[i][2] = 'O';
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == 'O' && board[i][0] == ' ')
		{
			board[i][0] = 'O';
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][0] == 'O' && board[i][1] == ' ')
		{
			board[i][1] = 'O';
			return 1;
		}
	}
	//遍历列优手判断：
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[0][i] == 'O' && board[2][i] == ' ')
		{
			board[2][i] = 'O';
			return 1;
		}
		if (board[1][i] == board[2][i] && board[1][i] == 'O' && board[0][i] == ' ')
		{
			board[0][i] = 'O';
			return 1;
		}
		if (board[0][i] == board[2][i] && board[0][i] == 'O' && board[1][i] == ' ')
		{
			board[1][i] = 'O';
			return 1;
		}
	}
	//右斜对角线优手判断：
	if (board[0][0] == board[1][1] && board[0][0] == 'O' && board[2][2] == ' ')
	{
		board[2][2] = 'O';
		return 1;
	}
	if (board[0][0] == board[2][2] && board[0][0] == 'O' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][2] && board[1][1] == 'O' && board[0][0] == ' ')
	{
		board[0][0] = 'O';
		return 1;
	}
	//左斜对角线优手判断：
	if (board[0][2] == board[1][1] && board[0][2] == 'O' && board[2][0] == ' ')
	{
		board[2][0] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][0] && board[1][1] == 'O' && board[0][2] == ' ')
	{
		board[0][2] = 'O';
		return 1;
	}
	if (board[0][2] == board[2][0] && board[0][2] == 'O' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	return 0;
}

        定义出进攻型着棋优化后，我们同样对电脑着棋函数进行改动：

void computer_move(char board[ROW][COL], int row, int col)
{
	printf("电脑正在着棋！\n");
	if (computer_Better_move(board, row, col))
	{
		;
	}
	else
	{
		if (computer_better_move(board, row, col))
		{
			;
		}
		else
		{
			while (1)
			{
				int x = rand() % row;
				int y = rand() % col;
				if (board[x][y] == ' ')
				{
					board[x][y] = 'O';
					break;
				}
			}
		}
	}
}

        其实现逻辑与防守型着棋优化完全一致，不同的是此处采用了嵌套判断，先进行进攻型判断，没有进攻条件时进行防守，既没有进攻条件也无需进行防守时，再进行随机着棋。

        至此，我们关于井字棋的着棋优化就完成了。

二、界面格式优化：

       我们目前写出的代码，运行起来后是这样的：

        这样一大串的打印形式，使得我们的界面看起来非常的不美观，那么有没有办法能够使得我们的界面看起来整洁一些呢？答案是，有。 

        我们可以通过使用下面两个语句来实现对界面的优化：

        1.Sleep休眠语句：

Sleep(num);

        它的作用是， 使程序在延长预定时间后继续执行下一个步骤，设置休眠时间的方式是修改Sleep后方括号内的参数num的数值，单位为毫秒。

        要注意的是该语句在使用时，需要引用头文件Windows.h：

#include<Windows.h>

        2.system语句：

int system(const char * command)

        该函数功能为执行 dos(windows系统) 或 shell(Linux/Unix系统) 命令，参数字符串command为命令名。另，在windows系统下参数字符串不区分大小写。

        我们一般情况下使用的系统为Windows系统，故针对Windows系统进行说明。在windows系统中，system函数直接在控制台调用一个command命令。

        该函数语句在使用时需引用头文件stdlib.h：

#include<stdlib.h>

        在这里对我们的井字棋游戏界面进行优化时需要用到的命令是：

system("cls");

        这个命令的作用通俗来讲就是“ 清屏 ”，使用该函数命令，可以实现将之前打印在屏幕上的内容进行清空，并继续打印接下来的内容。运用在我们的程序中，就可以实现在每一个步骤完成后进行清屏，再继续执行接下来的步骤。

        通过灵活的结合使用上面的两种语句，我们可以使我们的游戏程序界面变得简洁而流畅。

三、优化后最终全部代码：

        1.头文件game.h:

#pragma once

#define ROW 3
#define COL 3
//进行宏定义，好处是进行游戏修改时不需要对每个参数都进行修改

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<Windows.h>
//因为此头文件会被引用，故在此头文件中引用的其它头文件也会被包含引用

//头文件中进行函数的声明：
void init_board(char board[ROW][COL], int row, int col);
void print_board(char board[ROW][COL], int row, int col);
void player_move(char board[ROW][COL], int row, int col);
int computer_better_move(char board[ROW][COL], int row, int col);
void computer_move(char board[ROW][COL], int row, int col);
char is_win(char board[ROW][COL], int row, int col);

        2.函数功能文件game.h：

#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"

//棋盘初始化（使无着棋位置均使用空格占位）：
void init_board(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] = ' ';
		}
	}
}

//打印棋盘：
void print_board(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)
		{
			for (j = 0; j < col; j++)
			{
				printf("-------");
				if (j < col - 1)
				{
					printf("|");
				}
			}
			printf("\n");
		}
	}
}

//玩家着棋：
void player_move(char board[ROW][COL], int row, int col)
{
	while (1)
	{
		int x, y;
		x = y = 0;
		printf("请着棋：\n");
		printf("您想下在第几行：");
		scanf("%d", &x);
		Sleep(1000);
		printf("您想下在第几列：");
		scanf("%d", &y);
		Sleep(500);
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (board[x - 1][y - 1] == ' ')
			{
				board[x - 1][y - 1] = '*';
				system("cls");
				break;
			}
			else
			{
				system("cls");
				printf("这个位置已经有棋子了喔！请重新输入！\n");
				Sleep(1500);
				system("cls");
				print_board(board, ROW, COL);
			}
		}
		else
		{
			system("cls");
			printf("输入坐标有误，请重新输入！\n");
			Sleep(1500);
			system("cls");
			print_board(board, ROW, COL);
		}
	}
}

//电脑防守型着棋优手判定：
int computer_better_move(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][0] == '*' && board[i][2] == ' ')
		{
			board[i][2] = 'O';
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == '*' && board[i][0] == ' ')
		{
			board[i][0] = 'O';
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][0] == '*' && board[i][1] == ' ')
		{
			board[i][1] = 'O';
			return 1;
		}
	}
	//遍历列优手判断：
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[0][i] == '*' && board[2][i] == ' ')
		{
			board[2][i] = 'O';
			return 1;
		}
		if (board[1][i] == board[2][i] && board[1][i] == '*' && board[0][i] == ' ')
		{
			board[0][i] = 'O';
			return 1;
		}
		if (board[0][i] == board[2][i] && board[0][i] == '*' && board[1][i] == ' ')
		{
			board[1][i] = 'O';
			return 1;
		}
	}
	//右斜对角线优手判断：
	if (board[0][0] == board[1][1] && board[0][0] == '*' && board[2][2] == ' ')
	{
		board[2][2] = 'O';
		return 1;
	}
	if (board[0][0] == board[2][2] && board[0][0] == '*' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][2] && board[1][1] == '*' && board[0][0] == ' ')
	{
		board[0][0] = 'O';
		return 1;
	}
	//左斜对角线优手判断：
	if (board[0][2] == board[1][1] && board[0][2] == '*' && board[2][0] == ' ')
	{
		board[2][0] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][0] && board[1][1] == '*' && board[0][2] == ' ')
	{
		board[0][2] = 'O';
		return 1;
	}
	if (board[0][2] == board[2][0] && board[0][2] == '*' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	return 0;
}

//电脑进攻型着棋判定：
int computer_Better_move(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][0] == 'O' && board[i][2] == ' ')
		{
			board[i][2] = 'O';
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == 'O' && board[i][0] == ' ')
		{
			board[i][0] = 'O';
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][0] == 'O' && board[i][1] == ' ')
		{
			board[i][1] = 'O';
			return 1;
		}
	}
	//遍历列优手判断：
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[0][i] == 'O' && board[2][i] == ' ')
		{
			board[2][i] = 'O';
			return 1;
		}
		if (board[1][i] == board[2][i] && board[1][i] == 'O' && board[0][i] == ' ')
		{
			board[0][i] = 'O';
			return 1;
		}
		if (board[0][i] == board[2][i] && board[0][i] == 'O' && board[1][i] == ' ')
		{
			board[1][i] = 'O';
			return 1;
		}
	}
	//右斜对角线优手判断：
	if (board[0][0] == board[1][1] && board[0][0] == 'O' && board[2][2] == ' ')
	{
		board[2][2] = 'O';
		return 1;
	}
	if (board[0][0] == board[2][2] && board[0][0] == 'O' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][2] && board[1][1] == 'O' && board[0][0] == ' ')
	{
		board[0][0] = 'O';
		return 1;
	}
	//左斜对角线优手判断：
	if (board[0][2] == board[1][1] && board[0][2] == 'O' && board[2][0] == ' ')
	{
		board[2][0] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][0] && board[1][1] == 'O' && board[0][2] == ' ')
	{
		board[0][2] = 'O';
		return 1;
	}
	if (board[0][2] == board[2][0] && board[0][2] == 'O' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	return 0;
}

//电脑着棋：
//随机生成坐标，只要没有被占用，就着棋
void computer_move(char board[ROW][COL], int row, int col)
{
	printf("电脑正在着棋！\n");
	Sleep(1000);
	if (computer_Better_move(board, row, col))
	{
		;
	}
	else
	{
		if (computer_better_move(board, row, col))
		{
			;
		}
		else
		{
			while (1)
			{
				int x = rand() % row;
				int y = rand() % col;
				if (board[x][y] == ' ')
				{
					board[x][y] = 'O';
					break;
				}
			}
		}
	}
	system("cls");
}
	

//平局判定：
int is_full(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;
			}
		}
	}
	return 1;
}

//胜利判定：
char is_win(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][0];
			//返回赢家
		}
	}
	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[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 (is_full(board, row, col) == 1)
	{
		return 'Q';
	}
	return 'C';
}

        3.程序主体文件test.c：

#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"
//引用自定头文件

void menu()
{
	printf("************************\n");
	printf("************************\n");
	printf("**** 欢迎游玩三子棋 ****\n");
	printf("****     请选择     ****\n");
	printf("****   1.开始游戏   ****\n");
	printf("****   0.退出游戏   ****\n");
	printf("************************\n");
	printf("************************\n");
}

void game()
{
	char board[ROW][COL];
	//创建九宫格数组，用于处理着棋
	char ret = 0;
	//定义字符，用于判断输赢后跳出着棋循环
	init_board(board, ROW, COL);
	//将数组与行列数传递给封装函数进行初始化
	print_board(board, ROW, COL);
	//将初始化完成的棋盘进行打印
	while (1)
	{
		player_move(board, ROW, COL);
		//玩家进行着棋
		print_board(board, ROW, COL);
		ret = is_win(board, ROW, COL);
		if (ret != 'C')
		{
			break;
		}
		//判断输赢
		computer_move(board, ROW, COL);
		//电脑进行着棋
		print_board(board, ROW, COL);
		ret = is_win(board, ROW, COL);
		if (ret != 'C')
		{
			break;
		}
	}
	system("cls");
	if (ret == '*')
	{
		printf("恭喜玩家获得胜利！\n");
		Sleep(2000);
	}
	else if (ret == 'O')
	{
		printf("很遗憾，电脑取得了胜利。\n");
		Sleep(2000);
	}
	else if (ret == 'Q')
	{
		printf("棋逢对手！战至平局！\n");
		Sleep(2000);
	}
	system("cls");
}


void test()
{
	srand((unsigned int)time(NULL));
	//用时间戳来生成随机数，用于电脑着棋位置判断
	int input = 0;
	do
	{
		menu();
		printf("请您进行选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			Sleep(500);
			system("cls");
			game();
			break;
		case 0:
			break;
		default:
			printf("输入错误，请重新输入！\n");
			break;
		}
	} while (input);
}

int main()
{
	test();

	return 0;
}

四、总结：

        当我们完成以上优化后，一个游戏程序的雏形就完成了，我们对其功能和界面都进行了相当程度的优化。但是我们对于一个程序的优化过程，不仅仅如此而已，在以后的学习过程中，我们会学到更多知识，到时候我们还可以使用更高深的知识来对我们的游戏程序进行更深层次的优化。

        到这里我们今天的学习过程就告一段落啦，各位小伙伴们下去以后一定要多看多敲多理解，牢固的将知识掌握才是我们的最终目的！靠自己的力量一步步跨过泥泞，才能离想要的生活越来越近，人生中最好的贵人，永远是努力的自己！

        新人初来乍到，辛苦各位小伙伴们动动小手，三连走一走 ~ ~ ~  最后，本文仍有许多不足之处，欢迎各位看官老爷随时私信批评指正！

銮崽的干货分享基地
关注
  • 18
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
用C语言创建动态数组
07-23
本文讲述了如何用C语言也能创建动态数组的技巧，通过代码实例来演示分析，让你进一步了解数组的动态创建技巧与代码的艺术。
C语言第十四课：操作符详解（上）——算数、移位、位、赋值操作符
weixin_59392935的博客
11-26 1493
我们在前面几篇文章中对井字棋和扫雷两个阶段性练习进行了详细的练习讲解，想必各位小伙伴们对于前面学到的知识也能较为充分的掌握了。从本文开始，我们将继续进行下一部分关于操作符的学习。
数组越界及其避免方法，C语言数组越界详解
热门推荐
李肖遥的专栏
11-24 1万+
关注、星标公众号，直达精彩内容ID：技术让梦想更伟大作者：李肖遥所谓的数组越界，简单地讲就是指数组下标变量的取值超过了初始定义时的大小，导致对数组元素的访问出现在数组的范围之外，这类错误...
数组越界
zmjyjy的专栏
11-18 177
/*数组越界C语言编译器不会自己检查数组越界的，要靠程序员自己注意  如果越界，一般来说同样可以修改、访问，所以你的程序输出结果不变  但是要知道：越界部分是别的部分的数据甚至代码，修改、访问可能导致程序错误 */ #include void main()  {  int iOut = -1; int arr[4];  for ( int i = 0; i {  ar
C语言数组下标越界
am_03的博客
09-01 1427
数组越界的严重性 在 C 语言里，数组需为静态的。数组的大小需要在程序运行前就确定下来。 C语言数组越界的严重性在于对数组元素访问及修改的内容存在不确定性。 这类没有预知性的修改会导致无法确定的错误，发生缓冲区泄露漏洞。 这也就是数组越界的严重所在。 代码如下所示： 数组里的下标从0开始。 那么在上面代码只能访问：a[1]、a[2]、a[3]、a[4]、a[5]、a[6]、a[7]、a[8]、a[9] i自加到10时，a[10]属于数组下标越界。 详细分析图 1、栈把内存分配给数组，并且自上而下从小地址开
井字棋游戏C语言实现
04-28
井字棋游戏的C语言实现，两方玩家可以玩井字棋printf("请输入操作前的数字代号：\n1：新游戏\n2：退出\n"); scanf_s("%d", &op); if (op == 2) break; else if (op == 1) new_game(); else { ...
C语言visual studio创建的井字棋游戏
最新发布
03-08
【标题】：“C语言在Visual Studio中的...总之，“C语言在Visual Studio中的应用：创建井字棋游戏”是一个很好的实践项目，它将理论知识与实际编程相结合，对于C语言初学者来说，是提高技能和理解编程原理的有效途径。
井字棋游戏(C语言).pdf
09-30
根据给定的文件内容，可以分析出井字棋游戏的C语言实现涉及以下几个关键知识点： 1. C语言基础语法：文件中包含了多个C语言基本元素，如变量声明（例如：`int i, j;`），条件语句（例如：`if`），循环语句（例如：`...
井字棋游戏C语言版
02-05
井字棋游戏，也被称为“圈圈叉叉”或“三子连线”，是一种简单而经典的双人策略游戏。在这个版本中，游戏是用C语言编写的，这为开发者提供了更底层的控制，使得代码更加高效且易于理解。C语言是一种强大的、结构化的...
C语言实现井字棋
01-28
2. **字符数组与字符串**：井字棋的棋盘通常用二维字符数组来表示，每个元素代表棋盘的一个位置。C语言中的字符串实际上是字符数组，用于存储玩家的标记（如'X'或'O'）。 3. **游戏逻辑**：实现井字棋的核心在于...
C语言数组
AiErSanA的博客
06-01 744
C语言数组一维数组1.创建和初始化2.使用3.在内存中的存储二维数组1.创建和初始化2.使用3.在内存中的存储数组扩展数组名数组作为函数传参冒泡函数 一维数组 1.创建和初始化 <1>数组的创建 数组是一组相同类型元素的集合。 数组的创建方式: 数组创建的实例： //代码1 int arr1[10]; //代码2 int count = 10; int arr2[count];//数组不能正常创建 //代码3 char arr3[10]; float arr4[1]; double arr
C语言——数组
2301_76836325的博客
06-03 707
这与上面创建的数组的类型有关。这里也可以用来解释，为什么二维数组在进行初始化时，数组的行可以省略但是列不能省略，因为列代表了每行可以存放几个元素，进而反应数组的地址，如果在初始化时省略数组的列，则因为不知道每行存放几个元素，进而不知道这一行最后一个元素的地址，进而无法仅需创建下一行数组。同一行中，相邻的两个数组地址的差值为4，同样，相邻两行数值之间的元素差值也为4（即第一行最后一个元素的地址和下一行第一个元素的地址），同样，二维数组中，同一行中的每个元素是连续的，不同行之间的元素也是连续的。
C语言--数组的创建与使用
WangLongxyd的博客
01-22 8292
数组
C数组下标越界
aifuxun2845的博客
10-13 527
之前总听说C语言的各种毛病，今天算是遇到一个：数组下标越界 事情经过 两段完成不相干的代码，一段是测温度的，一段是测转速的。两段代码单独运行都没有问题，但是若运行测转速的代码，测温度的数据就会发生错误。 调试过程 一步查看，发现运行测转速之后，测温度的代码中的一个变量和一个数据的值就会发生诡异的错误 问题原因 数组下标越界 这个越界非常不明显,代码如下： GratingPulseWidt...
C语言 数组下标越界 - C语言零基础入门教程
猿说编程
08-19 4916
目录 一.数组下标越界简介 1、什么是数组访问越界？ 2、访问越界会出现什么结果？ 二.数组下标越界案例 三.防止数组下标越界方法 四.猜你喜欢 零基础 C/C++ 学习路线推荐 : C/C++ 学习目录 >> C 语言基础入门 一.数组下标越界简介 1、什么是数组访问越界？ 在 C 语言中，我们可以直接通过数组下标来访问数组中的元素； 如果一个数组定义为有n个元素，那么，对这n个元素（下标为0 到 n-1的元素）的访问都合法，如果对这n个元素之外的访问，就是非法的，称为**越
关于数组的下标越界
tr0824的博客
01-21 1万+
数组是用来存储数据的。数组是定长的连续的内存片段。因为数组的定长性，我们可以对数组进行多种操作。本篇记录的就是因为数组的定长性引起的下标越界问题。  首先，我们定义一个数组。 int a =new int [5];这表示我们定义了一个Int 型，长度为5的数组。 在eclipse中，可以用数组名.length得到数组的长度。需要注意的时，每一个数组，其第一个下标时从0开始的。 也就是0，1，
c语言 创建数组,C语言数组
weixin_39805180的博客
05-19 2441
在iOS开发中，有时候我们会用到C数组，C数组的创建和加入元素等。创建形如：类型 数组名[数组长度]这里的数组长度不一定要指定一个明确的长度，比如我们可以创建一个int类型的i，然后：类型 arr[i]以一个CLLocationCoordinate2D类型的数组为例1、首先我们指定数组长度，positions是一个OC数组NSUInteger cout = positions.count;2、声明...
C语言入门——数组
xcxhzjl的博客
12-05 2628
目录 一、一维数组的创建和初始化 1、数组的创建 2、数组的初始化 二、一维数组的使用 三、一维数组在内存中的存储 四、二维数组的创建和初始化 1、二维数组的创建 2、二维数组的初始化 五、二维数组的使用 六、二维数组在内存中的存储 七、数组作为函数参数：冒泡排序为例 八、数组的应用实例1：三子棋 九、数组的应用实例2：扫雷游戏 一、一维数组的创建和初始化 1、数组的创建 ●数组是一组相同类型元素的集合。 ●创建方式： type_t arr_name [const_n
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

銮崽的干货分享基地

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值