C语言保姆级教学实现扫雷（附源码与教程）

已于 2023-10-09 10:12:00 修改
阅读量138 收藏 2
点赞数 5
文章标签： c语言 开发语言 游戏程序
于 2023-10-09 09:43:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fmsaier/article/details/133680619
版权

文章目录


在这里插入图片描述

前言

上一篇给大家展示了井字棋的做法，本次则展示扫雷的做法，我们仍然尝试将扫雷的规则拆分化解，并使用C语言进行编程构造。同样，大家也可以尝试用easyX等工具进行GUI的制作，或者借助Unity等游戏引擎会更加方便，但本文章仅使用C语言进行编程与功能实现。

功能拆解

首先，我们对井字棋的功能进行拆分。

  1. 菜单的创建与Button功能。
  2. 棋盘以及地雷的创建初始化与可视化。
  3. 玩家拆弹功能，并实时更新棋盘（暂不实现鼠标检测，以键盘输入模拟过程）
  4. 实现连锁开格子的功能
  5. 实时判断游戏是否结束，设计胜利条件。

对功能模块实现拆分后，我们尝试编程实现对应功能。

功能实现

在分解完扫雷的各项功能之后，我们尝试进行分模块功能制作。

1）菜单的创建与Button功能

menu（）函数

目前本博客未制作GUI而使用纯文字制作开始页面，而menu（菜单）函数的功能就是完成对游戏页面的构造，实现游戏的可交互功能。示例代码如下：

//菜单
void menu()
{
	printf("****************************\n");
	printf("********做出您的选择********\n");
	printf("**1.开始游戏***0.结束游戏***\n");
}

Button功能

在菜单构建之后，我们的程序需要对玩家的交互做出反馈，这里就牵涉到制作按钮，实现对应的功能。目前实现的是游戏开始以及结束游戏两个按钮。示例代码如下：

		//选择模式，让玩家自行输入数字实现模式的选择
		printf("请选择>");
		scanf("%d", &input);
		switch (input)
		{
		//退出，如果输入0就直接退出
		case 0:
			printf("游戏退出\n");
			Sleep(1000);
			break;
		//开始游戏，如果输入1就开始游戏
		case 1:
			game();
			Sleep(1000);
			break;
		//要时刻检测玩家是否不安规则标准进行
		default:
			printf("选择错误，请重新选择\n");
			Sleep(1000);
			break;
		}

ps:如果使用Unity进行开发，这里可以直接使用Button，并且切换场景使用SceneManager.LoadScene（）会更加方便。

持续游玩功能

考虑到玩家可能在游玩一局后不打算结束，而选择再来一次的场景，程序也需要设计反复游玩的功能，而不是直接结束运行。示例代码如下：

int input = 0;
	//游戏循环开始
	do
	{
		//菜单
		menu();
		//选择模式
		printf("请选择>");
		scanf("%d", &input);
		switch (input)
		{
		//退出
		case 0:
			printf("游戏退出\n");
			Sleep(1000);
			break;
		//开始游戏
		case 1:
			game();
			Sleep(1000);
			break;
		default:
			printf("选择错误，请重新选择\n");
			Sleep(1000);
			break;
		}	
		//一轮结束清屏
		system("cls");

	} while (input != 0);

这样就实现了重复游玩的功能，当然Unity中的Update()功能即可自己实现。

  • 菜单的创建与Button功能。

2）棋盘的创建初始化与可视化

在玩家游玩的过程中，应实时更新棋盘情况一边玩家作出反应。因此需要实现棋盘的可视化以及实时更新。

棋盘的初始化

不同于井字棋只需要记录一个字符变量记录棋子，扫雷需要记录该格是否是炸弹，以及周围八格炸弹的数量，因此在制作棋盘时使用了结构体数组来实现。示例代码如下：

typedef struct Ceil
{
	int count;//记录周围炸弹数量
	bool isBoom;//记录是否是炸弹
	bool isAppear;//记录此格子是否已经被开过
}Ceil;

此为结构体的定义，其中bool的变量使用在C语言中需要stdbool.h这个头文件。

在说明了一个棋盘的格子类型之后，我们便可以使用结构体数组来制作棋盘并进行初始化。示例代码如下：

//初始化棋盘
void InitChess(Ceil chess[ROW][COL],int row,int col)
{
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			chess[i][j].isBoom = false;
			chess[i][j].count = 0;
			chess[i][j].isAppear = false;
		}
	}
}

二维数组的传参也可以使用数组指针进行传参，这里即可Ceil chess[ROW] [COL] 改为Ceil （*chess）[COL]，可达到相同效果。（之后的传参过程若出现二维数组均可使用数组指针进行代替，不再特意指出）

涉及到的宏定义

以下是整个代码用到的宏定义：

#define ROW 11//行
#define COL 11//列
#define BOOM_COUNT 20//炸弹数量

对棋盘的行数，列数以及整个棋盘中的炸弹个数进行了定义，方便后续的更改与代码的维护。

地雷的生成

如今我们已经拥有了一个棋盘，接下来我们就需要给棋盘上埋炸弹，这次采用最简单的随机数逻辑去生成炸弹，大家也可以选择加一些限制条件让炸弹更倾向于生成在边缘地区。示例代码如下：

//生成地雷
void CreateBoom(Ceil chess[ROW][COL], int row, int col, int boom_count)
{
	int x, y;
	bool isfull = false;
	srand((unsigned int)time(NULL));
	for (int i = 0; i < boom_count; i++)
	{
		while (!isfull)
		{
			x = rand() % (row - 2) + 1;
			y = rand() % (col - 2) + 1;
			if (chess[x][y].isBoom == false)
			{
				isfull = true;
				chess[x][y].isBoom = true;
			}
		}
		isfull = false;
	}
}

考虑到越界问题，在生成数组时特意将行数跟列数设计的比需要的多了2，以此方便边缘的格子遍历四周算炸弹个数。

棋盘的可视化

在实现了棋盘的初始化之后，我们需要在玩家开了一个格子后能看到棋盘的样子，以及能看到每个格子附近有多少炸弹，所以我们需要将棋盘进行打印。示例代码如下：

//打印棋盘
void PrintChess(Ceil chess[ROW][COL], int row, int col)
{
	for (int i = 1; i < row - 1; i++)
	{
		for (int j = 1; j < col - 1; j++)
		{
			if (chess[i][j].isAppear == true)
			{
				if (j < col - 2)
					printf(" %d |", chess[i][j].count);
				else
					printf(" %d  ", chess[i][j].count);
			}
			else
			{
				if (j < col - 2)
					printf("   |");
				else
					printf("    ");
			}

		}
		printf("\n");
		for (int j = 1; j < row - 1; j++)
		{
			printf("---");
			if (j < row - 2)
			{
				printf("|");
			}
		}
		printf("\n");
	}
}

这里选择将打印所有开过的格子的周围炸弹数量，如果周围没有炸弹则会显示0。如图示例：
在这里插入图片描述

当然，我们需要将该函数置于game()函数，并用while循环实现棋盘的实时打印。

  • 棋盘的创建初始化与可视化。

3）玩家拆弹功能

在拥有一个棋盘之后，我们需要做的就是实现玩家点击格子可以拆的功能。我们用键盘模拟点击格子的功能，当玩家输入他要开的棋盘坐标，我们就展现开后的结果将棋盘打印出来。示例代码如下：

//玩家开格子
int PlayerMove(Ceil chess[ROW][COL], int row, int col)
{
	int x, y;
	bool flag = false;
	while (!flag)
	{
		printf("请输入想点击位置坐标>");
		scanf("%d%d", &x, &y);
		system("cls");
		if (chess[x][y].isAppear == false)
		{
			if (chess[x][y].isBoom == false)
			{
				flag = true;
				AppearOne(chess, x, y);
				return 1;
			}
			else
			{
				printf("炸弹\n");
				printf("游戏结束\n");
				flag = true;
				return 0;
			}

		}
		else
			printf("坐标非法，请重新输入\n");

	}

}
  • 玩家拆弹功能。

4）连锁开格子功能

我将开格子的函数封装单独做了出来，在实际的扫雷游戏过程中，如果这个格子的周围没有炸弹，会实现连锁开格子的直到遇到一个周围有炸弹的格子，这里尝试用递归实现这个功能。示例代码如下：

//开一个
void AppearOne(Ceil chess[ROW][COL], int x, int y)
{
	if (chess[x][y].isAppear == false)
	{
		chess[x][y].isAppear = true;
		chess[x][y].count = ArroundCount(chess, x, y);
		if ((x > 0 && x < 10) && (y > 0 && y < 10) && chess[x][y].count == 0)
		{
			AppearArround(chess, x, y);
		}
	}
}
//开周围
void AppearArround(Ceil chess[ROW][COL], int x, int y)
{
	int count = 0;
	/*if (chess[x - 1][y - 1].isBoom == false)
	{
		AppearOne(chess, x - 1, y - 1);
	}*/
	if (chess[x - 1][y].isBoom == false)
	{
		AppearOne(chess, x - 1, y);
	}
	/*if (chess[x - 1][y + 1].isBoom == false)
	{
		AppearOne(chess, x - 1, y + 1);
	}*/
	if (chess[x][y - 1].isBoom == false)
	{
		AppearOne(chess, x, y - 1);
	}
	if (chess[x][y + 1].isBoom == false)
	{
		AppearOne(chess, x, y + 1);
	}
	/*if (chess[x + 1][y - 1].isBoom == false)
	{
		AppearOne(chess, x + 1, y - 1);
	}*/
	if (chess[x + 1][y].isBoom == false)
	{
		AppearOne(chess, x + 1, y);
	}
	/*if (chess[x + 1][y + 1].isBoom == false)
	{
		AppearOne(chess, x + 1, y + 1);
	}*/
}

开一个之后不断判断周围的格子是否都开过以及周围炸弹数量是否是0，然后去递归实现开格子的过程，这里里面也用到了去获取该格子周围炸弹数量的函数ArroundCount（），该函数代码如下：

//周围炸弹个数
int ArroundCount(Ceil chess[ROW][COL],int x, int y)
{
	int count = 0;
	if ((x > 0 && x < 10) && (y > 0 && y < 10))
	{
		if (chess[x - 1][y - 1].isBoom == true)
			count++;
		if (chess[x - 1][y].isBoom == true)
			count++;
		if (chess[x - 1][y + 1].isBoom == true)
			count++;
		if (chess[x][y - 1].isBoom == true)
			count++;
		if (chess[x][y + 1].isBoom == true)
			count++;
		if (chess[x + 1][y - 1].isBoom == true)
			count++;
		if (chess[x + 1][y].isBoom == true)
			count++;
		if (chess[x + 1][y + 1].isBoom == true)
			count++;
	}
	return count;
}

至此，我们便实现了玩家连锁开格子的功能，当然扫雷游戏实际上还有一个可以给炸弹标点的功能，但我们这次暂不实现，最终的胜利条件也是只要除了炸弹以外的格子都打开就算胜利。代码效果如图：

在这里插入图片描述

  • 连锁开格子功能。

5）设计胜利条件

最后我们需要设计函数去判断玩家是否胜利，我们设定胜利条件是只要除了炸弹以外的格子都打开就算胜利。示例代码如下：

//胜利
int isWin(Ceil chess[ROW][COL], int row, int col)
{
	bool flag = false;
	for (int i = 1; i < row - 1; i++)
	{
		for (int j = 1; j < col - 1; j++)
		{
			if (chess[i][j].isAppear == false && chess[i][j].isBoom == false)
			{
				flag = true;
			}
		}
	}
	if (flag == false)
	{
		printf("游戏胜利\n");
		return 1;
	}
	else
		return 0;
}
  • 设计胜利条件。

完整代码

1）test.c

#include "game.h"
int main()
{
	int input = 0;
	do
	{
		//菜单
		menu();
		printf("模式选择：请输入>");
		scanf("%d", &input);
		switch (input)
		{
			//退出
			case 0:
				break;
			//开始游戏
			case 1:
				game();
				break;
			default:
				printf("输入错误，请重新选择\n");
				break;
		}
		Sleep(1000);
		system("cls");
	} while (input);
	return 0;
}

2）game.h

#pragma once
#include <stdio.h>
#include <windows.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>

#define ROW 11//行
#define COL 11//列
#define BOOM_COUNT 15//炸弹数量

typedef struct Ceil
{
	int count;
	bool isBoom;
	bool isAppear;
}Ceil;

//菜单
void menu();

//初始化棋盘
void InitChess(Ceil chess[ROW][COL], int row, int col);

//打印棋盘
void PrintChess(Ceil chess[ROW][COL], int row, int col);

//打印炸弹位置
void PrintBoom(Ceil chess[ROW][COL], int row, int col);

//生成地雷
void CreateBoom(Ceil chess[ROW][COL], int row, int col);

//玩家开格子
int PlayerMove(Ceil chess[ROW][COL], int row, int col);

//周围炸弹个数
int ArroundCount(Ceil chess[ROW][COL], int x, int y);

//开一个
void AppearOne(Ceil chess[ROW][COL], int x, int y);

//开周围
void AppearArround(Ceil chess[ROW][COL], int x, int y);

//游戏主程序
void game();

//胜利
int isWin(Ceil chess[ROW][COL], int row, int col);

3）game.c

#include "game.h"

//typedef struct Ceil
//{
//	int count;//周围数量
//	bool isBoom;//是否是炸弹
// 	bool isAppear;//是否现行
//}Ceil;
//地雷是true,空白是false

//菜单
void menu()
{
	printf("****************************\n");
	printf("********做出您的选择********\n");
	printf("**1.开始游戏***0.结束游戏***\n");
}
//初始化棋盘
void InitChess(Ceil chess[ROW][COL],int row,int col)
{
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			chess[i][j].isBoom = false;
			chess[i][j].count = 0;
			chess[i][j].isAppear = false;
		}
	}
}
//打印棋盘
void PrintChess(Ceil chess[ROW][COL], int row, int col)
{
	for (int i = 1; i < row - 1; i++)
	{
		for (int j = 1; j < col - 1; j++)
		{
			if (chess[i][j].isAppear == true)
			{
				if (j < col - 2)
					printf(" %d |", chess[i][j].count);
				else
					printf(" %d  ", chess[i][j].count);
			}
			//显示炸弹测试用
			/*if (chess[i][j].isBoom == true)
			{
				if (j < col - 2)
					printf(" 1 |");
				else
					printf(" 1  ");
			}*/
			else
			{
				if (j < col - 2)
					printf("   |");
				else
					printf("    ");
			}

		}
		printf("\n");
		for (int j = 1; j < row - 1; j++)
		{
			printf("---");
			if (j < row - 2)
			{
				printf("|");
			}
		}
		printf("\n");
	}
}
//生成地雷
void CreateBoom(Ceil chess[ROW][COL], int row, int col, int boom_count)
{
	int x, y;
	bool isfull = false;
	srand((unsigned int)time(NULL));
	for (int i = 0; i < boom_count; i++)
	{
		while (!isfull)
		{
			x = rand() % (row - 2) + 1;
			y = rand() % (col - 2) + 1;
			if (chess[x][y].isBoom == false)
			{
				isfull = true;
				chess[x][y].isBoom = true;
			}
		}
		isfull = false;
	}
}
//玩家开格子
int PlayerMove(Ceil chess[ROW][COL], int row, int col)
{
	int x, y;
	bool flag = false;
	while (!flag)
	{
		printf("请输入想点击位置坐标>");
		scanf("%d%d", &x, &y);
		system("cls");
		if (chess[x][y].isAppear == false)
		{
			if (chess[x][y].isBoom == false)
			{
				flag = true;
				AppearOne(chess, x, y);
				return 1;
			}
			else
			{
				printf("炸弹\n");
				printf("游戏结束\n");
				flag = true;
				return 0;
			}

		}
		else
			printf("坐标非法，请重新输入\n");

	}

}
//开一个
void AppearOne(Ceil chess[ROW][COL], int x, int y)
{
	if (chess[x][y].isAppear == false)
	{
		chess[x][y].isAppear = true;
		chess[x][y].count = ArroundCount(chess, x, y);
		if ((x > 0 && x < 10) && (y > 0 && y < 10) && chess[x][y].count == 0)
		{
			AppearArround(chess, x, y);
		}
	}
}
//开周围
void AppearArround(Ceil chess[ROW][COL], int x, int y)
{
	int count = 0;
	/*if (chess[x - 1][y - 1].isBoom == false)
	{
		AppearOne(chess, x - 1, y - 1);
	}*/
	if (chess[x - 1][y].isBoom == false)
	{
		AppearOne(chess, x - 1, y);
	}
	/*if (chess[x - 1][y + 1].isBoom == false)
	{
		AppearOne(chess, x - 1, y + 1);
	}*/
	if (chess[x][y - 1].isBoom == false)
	{
		AppearOne(chess, x, y - 1);
	}
	if (chess[x][y + 1].isBoom == false)
	{
		AppearOne(chess, x, y + 1);
	}
	/*if (chess[x + 1][y - 1].isBoom == false)
	{
		AppearOne(chess, x + 1, y - 1);
	}*/
	if (chess[x + 1][y].isBoom == false)
	{
		AppearOne(chess, x + 1, y);
	}
	/*if (chess[x + 1][y + 1].isBoom == false)
	{
		AppearOne(chess, x + 1, y + 1);
	}*/
}
//周围炸弹个数
int ArroundCount(Ceil chess[ROW][COL],int x, int y)
{
	int count = 0;
	if ((x > 0 && x < 10) && (y > 0 && y < 10))
	{
		if (chess[x - 1][y - 1].isBoom == true)
			count++;
		if (chess[x - 1][y].isBoom == true)
			count++;
		if (chess[x - 1][y + 1].isBoom == true)
			count++;
		if (chess[x][y - 1].isBoom == true)
			count++;
		if (chess[x][y + 1].isBoom == true)
			count++;
		if (chess[x + 1][y - 1].isBoom == true)
			count++;
		if (chess[x + 1][y].isBoom == true)
			count++;
		if (chess[x + 1][y + 1].isBoom == true)
			count++;
	}
	return count;
}
//打印炸弹位置
void PrintBoom(Ceil chess[ROW][COL], int row, int col)
{
	for (int i = 1; i < row - 1; i++)
	{
		for (int j = 1; j < col - 1; j++)
		{
			
			//显示炸弹测试用
			if (chess[i][j].isBoom == true)
			{
				if (j < col - 2)
					printf(" 1 |");
				else
					printf(" 1  ");
			}
			else
			{
				if (j < col - 2)
					printf("   |");
				else
					printf("    ");
			}

		}
		printf("\n");
		for (int j = 1; j < row - 1; j++)
		{
			printf("---");
			if (j < row - 2)
			{
				printf("|");
			}
		}
		printf("\n");
	}
}
//胜利
int isWin(Ceil chess[ROW][COL], int row, int col)
{
	bool flag = false;
	for (int i = 1; i < row - 1; i++)
	{
		for (int j = 1; j < col - 1; j++)
		{
			if (chess[i][j].isAppear == false && chess[i][j].isBoom == false)
			{
				flag = true;
			}
		}
	}
	if (flag == false)
	{
		printf("游戏胜利\n");
		return 1;
	}
	else
		return 0;
}
//游戏主程序
void game()
{
	int boom = 0;
	int win = 0;
	//建立棋盘
	Ceil chess[ROW][COL];
	//初始化
	InitChess(chess, ROW, COL);
	//打印棋盘
	//PrintChess(chess, ROW, COL);
	//生成地雷
	CreateBoom(chess, ROW, COL, BOOM_COUNT);
	//打印地雷位置
	//PrintBoom(chess, ROW, COL);
	while (1)
	{
		//玩家开格子
		boom = PlayerMove(chess, ROW, COL);
		if (boom == 0)
			break;
		PrintChess(chess, ROW, COL);
		//胜利
		win = isWin(chess, ROW, COL);
		if (win == 1)
			break;
		
	}
}

这就是井字棋C语言实现的全部内容啦，期待我们的下次相遇，喜欢的可以点个关注再走哦！之后会持续更新更多的内容!

在这里插入图片描述

乀艨ic
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
扫雷游戏【可展开一片，超详细，保姆级别，此一篇足够】
FSRMWK的博客
01-16 1382
要传ROW,与COL的原因很简单，在开始，我们就说了我们只是为了方便处理棋盘边界坐标返回雷区的个数而行 列都+2，实际上真正要操作的还是未加之前的9x9的棋盘规模。在介绍扫雷游戏的规则制定的时候，提到过：计算周围的坐标雷的个数，可是若我们想要9x9的棋盘规格，就只定义9x9的二维数组。在玩家玩扫雷的时候，它会给你一个二维的棋盘（下面的讲解都以9x9规格为例子），然后点击你想排查的坐标，若不是雷的，则显示周围雷的个数。产生的雷的坐标是随机的，产生的雷的坐标不能重复，产生的雷不能超过我们布置的棋盘规格。
【C语言】扫雷（保姆级教程+内含源码）
幾微的学习博客
07-30 2186
本篇文章详细的，有体系的介绍了扫雷的结构，方便我们小白的更加理解C语言的数组。内含源码。
扫雷游戏的实现---c语言（保姆级讲解）
2401_84024092的博客
07-28 834
扫雷游戏网页版 - Minesweeper盘面上有许多方格，方格中随机分布着一些雷。你的目标是避开雷，找出所有不是雷的格子。一个非雷格中的数字表示以它为中心周围8格中的雷数，空白表示附近都没有地雷。可以利用这个信息推导出安全格（不是雷）和雷的位置。此图框内表示非雷格你可以用右键在你认为是雷的地方插旗（称为标雷），再次点击即可取消。扫雷游戏胜利的条件是不触发所有雷排查完其他所有坐标。大家可以先清楚规则点击上面的链接进行游戏，在尝试下面的学习！
如何实现精致扫雷游戏(可扩散可标记)---保姆级教程
zijin555的博客
08-08 1843
其实每个语句都不难，但是整体组合在一起就显得比较复杂，我们只需要一点点分析，用逻辑将他们联合起来就成功了！最后，希望这篇文章可以帮助到大家，喜欢的话记得三连哦~关注博主，后续会持续推迟优质内容~......
C语言扫雷游戏代码以及基本原理教学（一看就会）
wutongguo的博客
08-25 3183
0基础扫雷的代码实现以及设计思路保姆级教学 （保证一看就会）
c/c++语言用Easyx写出扫雷（保姆级教学），有源代码！！！！！！！！
weixin_50561752的博客
04-24 7365
#include <stdio.h> #include <stdlib.h> #include <time.h> #include <graphics.h> int grahight = 415;//实际画布高 int grawidth =340;//实际画布宽 #define allhight 100//总数组大小 #define allwidth 100//总数组大小 //中级17*17：415*340，初级10*10：275*200，高级20*20：4.
扫雷详解（附代码）（保姆级教学）
weixin_66046886的博客
05-18 1536
扫雷详解（附代码）（保姆级教学）
保姆级！C/C++语言实现扫雷图形化（附源码和素材贴图）
2301_79165368的博客
08-12 3605
C/C++语言实现扫雷图形化
【C语言】关于扫雷的三大问题，理解后，扫雷秒了！！！
Gao123456fy的博客
07-24 358
1. 为什么用两个数组 2. 为什么要在外面加一行 3. 为什么用字符 0 和字符 1 4. 小结
C语言实现扫雷游戏（有教程和源码）
02-07
C语言实现扫雷游戏（有教程和源码）
C语言扫雷（初级篇）附源码以及可执行文件
02-10
扫雷初级版本
C语言——扫雷游戏实现（超详解）
2301_80004913的博客
11-08 7500
扫雷游戏想必大家应该都玩过吧，这个游戏的目标呢就是在一个 9x9 的棋盘上找出所有没有地雷的格子，而不踩到地雷。当然这个9×9只是一个初级玩法，棋盘大小和雷的数量是可以随便设置的，有那种电脑满屏的模式，但是我没去尝试过，一般玩的都是初级9×9的模式，而本篇文章也主要说的是9×9扫雷游戏的实现。扫雷游戏网页版 - Minesweeper。
SpringBatch4升级SpringBatch5踩坑指南
三暮辰的博客
09-02 942
springbatch4升级springbatch5指南，全面踩坑，报错，位置，参考，解决方案等
一个php快速项目搭建框架源码，带一键CURD等功能
jiyc2008的博客
08-26 5253
框架易于功能扩展，代码维护，方便二次开发，帮助开发者简单高效降低二次开发成本，满足专注业务深度开发的需求。百度网盘下载。
虚幻引擎（Unreal Engine）技术使得《黑神话悟空传》大火，现在重视C++的开始吃香了，JAVA，Go，Unity都不能和C++相媲美！
zhang9880000的博客
08-27 3828
C++ 的虚拟引擎技术通常指的是使用 C++ 语言开发的游戏引擎，如虚幻引擎（Unreal Engine）等。以下是对 C++ 虚拟引擎技术一、强大的性能表现高效的内存管理C++ 允许开发者对内存进行精细的控制。在虚拟引擎中，可以根据具体需求进行内存分配和释放，避免不必要的内存开销。例如，在处理大规模场景和复杂模型时，可以通过自定义内存分配器来优化内存使用，提高性能。通过指针操作和直接内存访问，C++ 可以实现高效的数据存储和访问。
【unity知识】Animator动画状态的基本属性介绍
向宇
09-03 808
【unity知识】Animator动画状态的基本属性介绍
Unity数据持久化 之 反序列化2进制
最新发布
咩咩觉主的博客
09-05 255
嘻嘻
使用Unity的准备
wacanda的博客
09-05 281
Unity - 实时内容开发平台 | 3D、2D、VR & AR可视化。
【Unity小工具】Image组件宽度、高度自适应
憨辰
09-01 438
【代码】【Unity小工具】Image组件宽度、高度自适应。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值