C语言实现五子棋功能全解析

目录
  • 1、game.h
  • 2、test.c
  • 3、game.c
  • 4、游戏功能详解
    • (1)、棋盘初始化
    • (2)、棋盘的打印
    • (3)、玩家下棋
    • (4)、电脑下棋
    • (5)、判断游戏输赢
    • (6)、判断棋盘是否满了
  • 5、AI算法下棋
    • (1)、判断自己是否会赢(CheckComputer)
    • (2)、对玩家进行拦截(CheckPlayer)
    • (3)、加入AI算法后game.c的改动

1、game.h

game.h:自定义头文件,用于:

  • 库函数头文件的包含
  • 符号与结构的声明
  • 函数的定义
//防止头文件被重复包含
#pragma once
//头文件的包含
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
//符号的定义:使棋盘的大小可以跟着row和col的改变而改变
#define ROW 5
#define COL 5
//函数的声明
//棋盘初始化
void BoardInit(char arr[ROW][COL], int row, int col);
//打印棋盘
void BoardPrint(char arr[ROW][COL], int row, int col);
//玩家下棋
void PlayerMove(char arr[ROW][COL], int row, int col);
//电脑下棋
void ComputerMove(char arr[ROW][COL], int row, int col);
//判断输赢
char IsWin(char arr[ROW][COL], int row, int col);
//判断棋盘是否满了
int IsFull(char board[ROW][COL], int row, int col);

2、test.c

test.c:用于游戏逻辑的测试

#define _CRT_SECURE_NO_WARNINGS 1
//自定义头文件的包含
#include"game.h"
void menu()
{
	printf("================================\n");
	printf("=========  1. play    ==========\n");
	printf("=========  0. exit    ==========\n");
	printf("================================\n");
}
//游戏逻辑的实现
void game()
{
	//定义一个二维数组来存储下棋的数据
	char arr[ROW][COL] = { 0 };
	//棋盘初始化
	BoardInit(arr, ROW, COL);
	//打印棋盘
	BoardPrint(arr, ROW, COL);
	char ch = 0;
	while (1)
	{
		//玩家下棋
		PlayerMove(arr, ROW, COL);
		//打印棋盘
		BoardPrint(arr, ROW, COL);
		//判断输赢
		ch = IsWin(arr, ROW, COL);
		if (ch != 'C')
			break;
		//电脑下棋
		ComputerMove(arr, ROW, COL);
		//打印棋盘
		BoardPrint(arr, ROW, COL);
		//判断输赢
		ch = IsWin(arr, ROW, COL);
		if (ch != 'C')
			break;
	}
	if (ch == '*')
		printf("直接拿下!\n");
	else if (ch == '#')
		printf("你竟然打不过人机!\n");
	else
		printf("平局,得加油啊!\n");
}
int main()
{
	int input = 0;
	//设置随机数种子
	srand((unsigned int)time(NULL));
	do {
		//菜单
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input) {
		case 1:
			//玩游戏
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("输入错误,请重新输入!\n");
			break;
		}
	} while (input);
	return 0;
}

3、game.c

game.c:游戏功能的实现

#define _CRT_SECURE_NO_WARNINGS 1
//自定义头文件的包含
#include"game.h"
//函数的定义
//棋盘初始化
void BoardInit(char arr[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			arr[i][j] = ' ';
		}
	}
}
//打印棋盘
void BoardPrint(char arr[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		//打印分割竖向分割
		for (j = 0; j < col; j++)
		{
			printf(" %c ", arr[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 PlayerMove(char arr[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))
		{
			//把玩家坐标对应数组下标
			x -= 1;
			y -= 1;
			//判断坐标是否被占用
			if (arr[x][y] == ' ')
			{
				arr[x][y] = '*';  //假设玩家为*号
				break;
			}
			else
			{
				printf("该坐标已被占用\n");
			}
		}
		else
		{
			printf("坐标非法\n");
		}
	}
}
//电脑下棋
void ComputerMove(char arr[ROW][COL], int row, int col)
{
	printf("电脑下棋\n");
	while (1)
	{
		//在主函数生成种子srand
		//随机生成范围内的坐标
		int x = rand() % row;
		int y = rand() % col;
		//判断坐标是否被占用
		if (arr[x][y] == ' ')
		{
			arr[x][y] = '#';  //假设电脑为#号
			break;
		}
	}
}
//判断输赢
char IsWin(char board[ROW][COL], int row, int col)
{
	/*
	* 约定返回*代表玩家赢
	* 返回#代表电脑赢
	* 返回D代表平局
	* 返回C代表继续
	*/
	int i = 0;
	int j = 0;
	//判断行
	for (i = 0; i < row; i++)
	{
		int count = 0;  //标记相同棋子的个数
		for (j = 0; j < col - 1; j++)
		{
			if (board[i][j] == board[i][j + 1] && board[i][j] != ' ')
				count++;
		}
		if (count == col - 1)   //一次判断有两个棋子
			return board[i][j];
	}
	//判断列
	for (i = 0; i < col; i++)
	{
		int count = 0;
		for (j = 0; j < row - 1; j++)
		{
			if (board[j][i] == board[j + 1][i] && board[j][i] != ' ')
			{
				count++;
			}
		}
		if (count == row - 1)
			return board[j][i];
	}
	//判断两条斜边
	//第一条
	int count = 0;
	for (i = 0, j = 0; i < row - 1 && j < col - 1; i++, j++)
	{
		if (board[i][j] == board[i + 1][j + 1] && board[i][j] != ' ')
			count++;
	}
	if (count == row - 1)
		return board[i][j];
	//第二条
	count = 0;  //把count重新置为0(易错)
	//注意:这里i+1,j-1,所以i小于row-1,j>0,而不是i<row,j>=0(易错)
	for (i = 0, j = col - 1; i < row - 1 && j > 0; i++, j--)
	{
		if (board[i][j] == board[i + 1][j - 1] && board[i][j] != ' ')
			count++;
	}
	if (count == row - 1)
		return board[i][j];
	//判断棋盘是否满了
	if (IsFull(board, row, col))
	{
		return 'D';
	}
	//如果上述情况都没有返回,游戏继续
	return 'C';
}
	//判断棋盘是否满了
	if (IsFull(board, row, col))
	{
		return 'D';
	}
	//如果上述情况都没有返回,游戏继续
	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;   //有空格就返回0
		}
	}
	return 1;
}

4、游戏功能详解

(1)、棋盘初始化

void BoardInit(char arr[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			arr[i][j] = ' ';
		}
	}
}

(2)、棋盘的打印

void BoardPrint(char arr[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		//打印分割竖向分割
		for (j = 0; j < col; j++)
		{
			printf(" %c ", arr[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");
	}
}

(3)、玩家下棋

void PlayerMove(char arr[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))
		{
			//把玩家坐标对应数组下标
			x -= 1;
			y -= 1;
			//判断坐标是否被占用
			if (arr[x][y] == ' ')
			{
				arr[x][y] = '*';  //假设玩家为*号
				break;
			}
			else
			{
				printf("该坐标已被占用\n");
			}
		}
		else
		{
			printf("坐标非法\n");
		}
	}
}

(4)、电脑下棋

void ComputerMove(char arr[ROW][COL], int row, int col)
{
	printf("电脑下棋\n");
	while (1)
	{
		//在主函数生成种子srand
		//随机生成范围内的坐标
		int x = rand() % row;
		int y = rand() % col;

		//判断坐标是否被占用
		if (arr[x][y] == ' ')
		{
			arr[x][y] = '#';  //假设电脑为#号
			break;
		}
	}
}

(5)、判断游戏输赢

char IsWin(char board[ROW][COL], int row, int col)
{
	/*
	* 约定返回*代表玩家赢
	* 返回#代表电脑赢
	* 返回D代表平局
	* 返回C代表继续
	*/
	int i = 0;
	int j = 0;
	//判断行
	for (i = 0; i < row; i++)
	{
		int count = 0;  //标记相同棋子的个数
		for (j = 0; j < col - 1; j++)
		{
			if (board[i][j] == board[i][j + 1] && board[i][j] != ' ')
				count++;
		}
		if (count == col - 1)   //一次判断有两个棋子
			return board[i][j];
	}
	//判断列
	for (i = 0; i < col; i++)
	{
		int count = 0;
		for (j = 0; j < row - 1; j++)
		{
			if (board[j][i] == board[j + 1][i] && board[j][i] != ' ')
			{
				count++;
			}
		}
		if (count == row - 1)
			return board[j][i];
	}
	//判断两条斜边
	//第一条
	int count = 0;
	for (i = 0, j = 0; i < row - 1 && j < col - 1; i++, j++)
	{
		if (board[i][j] == board[i + 1][j + 1] && board[i][j] != ' ')
			count++;
	}
	if (count == row - 1)
		return board[i][j];
	//第二条
	count = 0;  //把count重新置为0(易错)
	//注意:这里i+1,j-1,所以i小于row-1,j>0,而不是i<row,j>=0(易错)
	for (i = 0, j = col - 1; i < row - 1 && j > 0; i++, j--)
	{
		if (board[i][j] == board[i + 1][j - 1] && board[i][j] != ' ')
			count++;
	}
	if (count == row - 1)
		return board[i][j];
	//判断棋盘是否满了
	if (IsFull(board, row, col))
	{
		return 'D';
	}
	//如果上述情况都没有返回,游戏继续
	return 'C';
}
	//判断棋盘是否满了
	if (IsFull(board, row, col))
	{
		return 'D';
	}
	//如果上述情况都没有返回,游戏继续
	return 'C';
}

(6)、判断棋盘是否满了

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;   //有空格就返回0
		}
	}
	return 1;
}

5、AI算法下棋

大家可以发现,在上面的代码中,电脑下棋是非常笨拙的,因为电脑产生的坐标是随机的,即不会拦截玩家,也不会判断自己,所以这里我们可以设计一个小小的算法来让电脑变得聪明起来,让它拥有拦截和判断功能。具体思路和代码如下:

(1)、判断自己是否会赢(CheckComputer)

//电脑检查自己是否会赢
//约定如果在函数内部成功判断就返回1
//判断失败则返回0
int CheckComputer(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][0] == '#' && board[i][2] == ' ')
		{
			board[i][2] = '#';
			return 1;   //成功判断,返回1
		}
		if (board[i][0] == board[i][2] && board[i][0] == '#' && board[i][1] == ' ')
		{
			board[i][1] = '#';
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == '#' && board[i][0] == ' ')
		{
			board[i][0] = '#';
			return 1;
		}
	}
	//判断每一列是否有两个相连的棋子,如果有,且第三个棋格为空,则落棋
	for (j = 0; j < col; j++)
	{
		if (board[0][j] == board[1][j] && board[0][j] == '#' && board[2][j] == ' ')
		{
			board[2][j] = '#';
			return 1;
		}
		if (board[0][j] == board[2][j] && board[0][j] == '#' && board[1][j] == ' ')
		{
			board[1][j] = '#';
			return 1;
		}if (board[1][j] == board[2][j] && board[1][j] == '#' && board[0][j] == ' ')
		{
			board[0][j] = '#';
			return 1;
		}
	}
	//判断两条对角线是否有两个相连的棋子,如果有,且第三个棋格为空,则落棋
	{
		//第一条
		if (board[0][0] == board[1][1] && board[0][0] == '#' && board[2][2] == ' ')
		{
			board[2][2] = '#';
			return 1;
		}
		if (board[0][0] == board[2][2] && board[0][0] == '#' && board[1][1] == ' ')
		{
			board[1][1] = '#';
			return 1;
		}
		if (board[1][1] == board[2][2] && board[1][1] == '#' && board[0][0] == ' ')
		{
			board[0][0] = '#';
			return 1;
		}
		//第二条
		if (board[0][2] == board[1][1] && board[0][2] == '#' && board[2][0] == ' ')
		{
			board[2][0] = '#';
			return 1;
		}
		if (board[0][2] == board[2][0] && board[0][2] == '#' && board[1][1] == ' ')
		{
			board[1][1] = '#';
			return 1;
		}
		if (board[1][1] == board[2][0] && board[1][1] == '#' && board[0][2] == ' ')
		{
			board[0][2] = '#';
			return 1;
		}
		//如果上面都没返回,说明不符合赢的条件,返回0
		return 0;
	}
}

(2)、对玩家进行拦截(CheckPlayer)

//电脑检查玩家是否会赢(逻辑和CheckComputer完全相同)
//约定成功拦截返回1
//无需拦截或者拦截不了返回0
int CheckPlayer(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][0] == '*' && board[i][2] == ' ')
		{
			board[i][2] = '#';
			return 1;   //成功拦截,返回1
		}
		if (board[i][0] == board[i][2] && board[i][0] == '*' && board[i][1] == ' ')
		{
			board[i][1] = '#';
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == '*' && board[i][0] == ' ')
		{
			board[i][0] = '#';
			return 1;
		}
	}
	//判断每一列是否有两个相连的棋子,如果有,且第三个棋格为空,则拦截
	for (j = 0; j < col; j++)
	{
		if (board[0][j] == board[1][j] && board[0][j] == '*' && board[2][j] == ' ')
		{
			board[2][j] = '#';
			return 1;
		}
		if (board[0][j] == board[2][j] && board[0][j] == '*' && board[1][j] == ' ')
		{
			board[1][j] = '#';
			return 1;
		}if (board[1][j] == board[2][j] && board[1][j] == '*' && board[0][j] == ' ')
		{
			board[0][j] = '#';
			return 1;
		}
	}
	//判断两条对角线是否有两个相连的棋子,如果有,且第三个棋格为空,则拦截
	{
		//第一条
		if (board[0][0] == board[1][1] && board[0][0] == '*' && board[2][2] == ' ')
		{
			board[2][2] = '#';
			return 1;
		}
		if (board[0][0] == board[2][2] && board[0][0] == '*' && board[1][1] == ' ')
		{
			board[1][1] = '#';
			return 1;
		}
		if (board[1][1] == board[2][2] && board[1][1] == '*' && board[0][0] == ' ')
		{
			board[0][0] = '#';
			return 1;
		}
		//第二条
		if (board[0][2] == board[1][1] && board[0][2] == '*' && board[2][0] == ' ')
		{
			board[2][0] = '#';
			return 1;
		}
		if (board[0][2] == board[2][0] && board[0][2] == '*' && board[1][1] == ' ')
		{
			board[1][1] = '#';
			return 1;
		}
		if (board[1][1] == board[2][0] && board[1][1] == '*' && board[0][2] == ' ')
		{
			board[0][2] = '#';
			return 1;
		}
		//如果上面都没返回,说明不符合拦截的条件,返回0
		return 0;
	}
}

注意:我这里采用的判断方法是枚举,由于五子棋的枚举情况比较复杂,而我目前也没想到更好的算法来进行判断,所以这里我只写了三子棋的AI判断代码,如果有大佬有更好的算法或者判断思路,欢迎在评论区留言。

(3)、加入AI算法后game.c的改动

上面我们已经完成了CheckComputer和CheckPlayer这两个函数的定义,现在我们只需要把这两个函数实现放入到game.c中并且在在电脑下棋(ComputerMove)中调用这两个函数即可。

//电脑下棋
void ComputerMove(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋\n");
	//定义两个标识符变量来接收两个判断函数的返回值
	int flag1 = 0;
	int flag2 = 0;
	flag1 = CheckComputer(board, row, col);
	//如果flag1 == 0 时才进行flag2 的判断,避免当二者都为1时下两步棋(易错)
	if (flag1 == 0)
	{
		flag2 = CheckPlayer(board, row, col);
	}
	if (flag1 == 0 && flag2 == 0)   //当CheckComputer和CheckPlayer都没落棋时,就随机下
	{
		while (1)
		{
			//在主函数生成种子srand
			//随机生成范围内的坐标
			int x = rand() % row;
			int y = rand() % col;
			//判断坐标是否被占用
			if (board[x][y] == ' ')
			{
				board[x][y] = '#';  //假设电脑为#号
				break;
			}
		}
	}
}

注意:这里的AI算法只适用于三子棋,如果要使用的话需要把头文件中的ROW和COL改为3,同时不要忘记在头文件中对两个判断函数进行声明。

到此这篇关于C语言实现五子棋功能全解析的文章就介绍到这了,更多相关C语言五子棋内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 基于C语言实现简单五子棋游戏

    本文实例为大家分享了C语言实现简单五子棋游戏的具体代码,供大家参考,具体内容如下 五子棋大家都玩儿过,所以规则就不介绍了 今天遇到一个学弟在实现的时候遇到一些问题,所以将实现的过程记录下 水平有限,仅供参考,互相交流,共同进步. #include<stdio.h> #include<windows.h>   int main() {       int i,j;//表示棋盘横纵坐标     /*********************************************

  • 利用C语言实现五子棋游戏

    本文实例为大家分享了C语言实现五子棋游戏的具体代码,供大家参考,具体内容如下 一.前言 本文将先介绍五子棋运行所需要的函数,最后串联成完整代码. 我们需要实现的功能有:1.菜单menu函数 2.初始化棋盘Initboard函数 3.显示棋盘Displayboard函数 4.实现人机.人人模式的选择 5.落子函数 playermove  computermove 6.判断输赢ifwin函数 先来看看运行效果吧! 二.头文件 #define _CRT_SECURE_NO_WARNINGS #incl

  • 用C语言实现五子棋小游戏

    简介 本次五子棋使用的是光标控制移动,通过按空格键(键值32)来落子,实现游戏的. 我们额外用到的头文件有: #include<getch.h>   通过调用getch()函数来识别 上下左右以及空格的操作. #include<stdlib.h>   采用 system("clear");清理屏幕,实现视觉上的走动效果. include<stdbool.h> stdbool.h 头文件对布尔类型进行了模拟 返回 true false 大致思路 需要的

  • 用C语言实现简单五子棋小游戏

    本文实例为大家分享了C语言实现简单五子棋小游戏的具体代码,供大家参考,具体内容如下 在vs2019创建新项目,然后添加两个源文件test.c和game.c,接着创建一个头文件game.h. test.c: #include "game.h" void game() { char board[ROW][COL]; InitBoard(board, ROW, COL); DisplayBoard(board, ROW, COL); char ret = 0; while (1) { Pla

  • C语言实现控制台五子棋小游戏

    这是一个用C语言实现的控制台小游戏--五子棋,棋盘大小和获胜棋子数目是用宏定义的,可以自定义,所以可以轻松改为三子棋.六子棋等等.此游戏设定为人机对战(PVE),电脑走棋是随机的. 编译环境:VS2015 此程序采用多文件编译,共有三个文件,一个game.h头文件,一个game.c文件和一个main.c文件,代码分别如下: game.h 这里是一些数据和函数的声明 #ifndef _GAME_H_ #define _GAME_H_ #define _BOARD_ 10 //棋盘大小 #defin

  • c语言实现简单的五子棋游戏

    本文实例为大家分享了c语言实现简单五子棋游戏的具体代码,供大家参考,具体内容如下 环境vs2017 一.游戏设计思想 1.该代码设置为 玩家1(*) vs 玩家2(O) 2.选择玩游戏 2.1 显示棋盘,玩家1下棋,判断游戏结果2.2 显示棋盘,玩家2下棋,判断游戏结果  3.判断游戏结果 有4种结果,玩家1赢,玩家2赢,平局,继续游戏若结果为玩家1赢或玩家2赢或平局,则显示结果,退回菜单界面,不再循环下棋        若结果为继续,则循环2.1和2.2 4.选择退出,则退出游戏 二.图片解说

  • C语言实现简单五子棋游戏

    在生活中五子棋是一个十分普遍的一款游戏,今天让我们一起来实现这款游戏. 1.初始化棋盘 char ret; //数据存储在一个二维数组中,玩家下去*,电脑下去#. char board[row][col] = { 0 };//最开始为全是空格 InitBoard(board,row,col);//初始化棋盘 我们利用InitBoard函数来初始化棋盘,用 * 来表示玩家下棋,用 # 来表示电脑下棋. 代码如图: void InitBoard(char board[row][col], int R

  • C语言版五子棋游戏的实现代码

    这次看了几位大佬的做法,我们也做了很多修改尝试.算是第一次尝试合作完成项目. 我认为学到的东西: 1.第一次尝试写项目,把函数分到不同的.c文件中后更好看了一些. 2.在研究过程中应该分清主次.代码正确运行才是基础要求,其他什么美化界面,调字体调颜色都并非重点. 3.从代码中学到的,①是采用落子数来判断该轮到黑方下还是白方下(落子数为2的倍数时黑方下,否则白方下),这样也能判断出是哪一方胜利,而且落子数还可以判断棋盘是否下满(==16*16时棋盘落满,平局) ②是胜利条件的判断,以中间子为参考,

  • C语言实现五子棋功能全解析

    目录 1.game.h 2.test.c 3.game.c 4.游戏功能详解 (1).棋盘初始化 (2).棋盘的打印 (3).玩家下棋 (4).电脑下棋 (5).判断游戏输赢 (6).判断棋盘是否满了 5.AI算法下棋 (1).判断自己是否会赢(CheckComputer) (2).对玩家进行拦截(CheckPlayer) (3).加入AI算法后game.c的改动 1.game.h game.h:自定义头文件,用于: 库函数头文件的包含 符号与结构的声明 函数的定义 //防止头文件被重复包含 #

  • C语言 队列的实现全解析

    目录 队列的实现 基本概念 创建结构体 初始化结构体 销毁队列结构体 入队 出队 判断队列是否为空 访问对头的值 访问队尾的值 返回队列的长度 Queue.h Queue.c Test.c “ 江天一色无纤尘,皎皎空中孤月轮. ” 队列的实现 基本概念 队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出 FIFO(First In First Out) 入队列:进行插入操作的一端称为队尾 出队列:进行删除操作的一端称为队头 队列也可以数组和链表的结构实现,

  • C语言 队列的实现全解析

    目录 队列的实现 基本概念 创建结构体 初始化结构体 销毁队列结构体 入队 出队 判断队列是否为空 访问对头的值 访问队尾的值 返回队列的长度 Queue.h Queue.c Test.c 队列的实现 基本概念 队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出 FIFO(First In First Out) 入队列:进行插入操作的一端称为队尾 出队列:进行删除操作的一端称为队头 队列也可以数组和链表的结构实现,使用链表的结构实现更优一些,因为如果使用数

  • window.open的功能全解析

    [1.最基本的弹出窗口代码]  其实代码非常简单:  <SCRIPT LANGUAGE="javascript">  <!--  window.open ('page.html')  -->  </SCRIPT>  因为着是一段javascripts代码,所以它们应该放在<SCRIPT LANGUAGE="javascr ipt">标签和</script>之间.<!-- 和 -->是对一些版本低

  • PHP实现类似于C语言的文件读取及解析功能

    本文实例讲述了PHP实现类似于C语言的文件读取及解析功能.分享给大家供大家参考,具体如下: $log_file_name = 'D:/static/develop/kuai_zhi/acagrid.com/public/Logs/'.date('Ym').'/'.date('d').'_error.log'; //$log_file_name = 'D:/static/develop/kuai_zhi/acagrid.com/public/Logs/201701/19_error.log'; i

  • C语言自定义类型全解析

    目录 前言 结构体类型 结构体的声明 结构体变量的定义与初始化 结构体的自引用 结构体的访问 结构体的传参 传结构体 传地址 结构体的内存对齐(强烈建议观看) 位段 位段的声明 位段的内存管理 位段的跨平台性  枚举类型 枚举类型的定义 枚举类型赋予初始值 枚举类型的优点 联合体类型 联合体的定义 联合体的特点  联合体内存大小的计算 前言 初学C语言 我们先接触的都是内置的类型 比如说int char short float double long等等 这一期就来聊一聊自定义类型的知识 结构体

  • webpack3之loader全解析

    首先亮出webpack官方网站,webpack能干什么?官网给出的答案就是,一句话,让一切变得简单! 各式各样的loader层出不穷,让我们在构建时不知所措,于此,总结下loader的全解析. 概念 loader,顾名思义,加载器,英文的解释如下: Loaders are transformations that are applied on the source code of a module. They allow you to pre-process files as you impor

  • java agent使用全解析

    今天打算写一下 Java agent,一开始我对它的概念也比较陌生,后来在别人口中听到 字节码插桩,bTrace,Arthas后面才逐渐了解到Java还提供了这么个工具. JVM启动前静态Instrument Java agent 是什么? Java agent是java命令的一个参数.参数 javaagent 可以用于指定一个 jar 包,并且对该 java 包有2个要求: 这个 jar 包的 MANIFEST.MF 文件必须指定 Premain-Class 项. Premain-Class

  • C# 单元测试全解析

    目录 1.前言 2.单元测试 2.1 单元测试的定义 2.2 单元测试的好处 2.3 单元测试的原则 3..NET 中的测试框架 3.1 MS Test 3.2 NUnit 3.3 XUnit 4.XUnit 的基本使用 5.其他 1.前言 "不会写单元测试的程序员不是合格的程序员,不写单元测试的程序员不是优秀的工程师." 那么问题来了,什么是单元测试,如何做单元测试. 2.单元测试 2.1 单元测试的定义 按照维基百科上的说法,单元测试(Unit Testing)又称为模块测试, 是

随机推荐