【C语言】2048小游戏【附源码】

news2024/11/26 11:39:50

一、游戏描述：

        2048是一款数字益智类游戏，玩家需要使用键盘控制数字方块的移动，合并相同数字的方块，最终达到数字方块上出现“2048”的目标。

        每次移动操作，所有数字方块会朝着指定方向同时滑动，并在靠近边界或其他数字方块时停止。如果两个相邻的数字方块数字相同，则它们会合并成一个方块，数字值为原先相同方块的数字值相加。

二、效果展示

三、代码讲解：

        实现了一个2048游戏的基本功能，包括初始化游戏界面、移动方块、放置新数字以及判定胜负等功能：

  1. DisplayBoard(int board[ROW][COL])：初始化并打印游戏界面。这个函数用于显示游戏的当前状态，包括棋盘上的数字和空格。

  2. init_num(int board[ROW][COL])：在游戏开始时随机生成两个数字2。这个函数用于初始化游戏棋盘，给棋盘上的两个随机位置赋值为2。

  3. put_num(int board[ROW][COL])：在每次移动后随机放置一个数字2或4。这个函数用于在每次玩家移动后，在空白的位置随机生成一个数字2或4。

  4. up(int board[ROW][COL])、down(int board[ROW][COL])、left(int board[ROW][COL])、right(int board[ROW][COL])：分别实现了向上、向下、向左、向右移动的功能。这些函数用于处理玩家的移动操作，更新棋盘上的数字位置。

  5. is_win(int board[ROW][COL])：判断是否获胜。这个函数用于检查游戏是否达到了2048，如果有一个位置的值为2048，则游戏获胜。

  6. is_fail(int board[ROW][COL])：判断是否失败。这个函数用于检查游戏是否失败，即所有位置都被填满且无法进行有效的移动操作。

#pragma once


#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <windows.h>
#include<conio.h>

#define ROW 4
#define COL 4
const int copy[ROW][COL];

//初始化并打印游戏界面
void DisplayBoard(int board[ROW][COL]);
//开局随机生成两个2
void init_num(int board[ROW][COL]);
//在移动后随机放置数字2或4
void put_num(int board[ROW][COL]);
//移动
void up(int board[ROW][COL]);
void down(int board[ROW][COL]);
void left(int board[ROW][COL]);
void right(int board[ROW][COL]);
//判定胜负
int is_win(int board[ROW][COL]);
int is_fail(int board[ROW][COL]);

显示2048游戏的棋盘界面

        

  1. 打印横向的分隔线，使用"+"和"-"来表示。
  2. 遍历每个格子，如果格子上有数字，则打印该数字并确保宽度为5个字符，右对齐；如果格子上没有数字，则打印5个空格。
  3. 在每行末尾打印"|"
  4. 再次打印横向的分隔线，使用"+"和"-"来表示。
void DisplayBoard(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	printf("tip：*方向键控制方块移动*ESC键返回菜单*\n");
	for (int j = 0; j < COL; j++)
		printf("+-----");
	printf("+\n");
	for (int i = 0; i < ROW; i++)
	{
		for (int j = 0; j < COL; j++)
		{
			printf("|");
			if (board[i][j] != 0)
				printf("%5d", board[i][j]);

			else
				printf("     ");
		}
		printf("|\n");
		for (int j = 0; j < COL; j++)
		{
			printf("+-----");
		}
		printf("+\n");
	}
}

 

初始化游戏棋盘：

        

  1. 生成一个随机的行索引 x 和列索引 y，确保它们在棋盘范围内。
  2. 在随机选择的位置 (x, y) 上放置一个数字2。
  3. 再次生成一个随机的行索引 x 和列索引 y，确保它们与第一个位置不重复。
  4. 在新的随机选择的位置 (x, y) 上放置另一个数字2。
void init_num(int board[ROW][COL])
{
	int x, y;
	x = rand() % ROW;
	y = rand() % COL;
	board[x][y] = 2;//随机在一个位置生成2
	x = rand() % ROW;
	y = rand() % COL;
	while (board[x][y] == 2)
	{
		x = rand() % ROW;
		y = rand() % COL;
	}
	board[x][y] = 2;
	return;
}

空白位置随机放置一个数字：

  1. 生成一个随机的行索引 x 和列索引 y，确保它们在棋盘范围内。
  2. 如果在选择的位置 (x, y) 上已经有数字，则继续随机选择位置，直到找到一个空白位置。
  3. 生成一个随机数 z，范围为0到9之间的整数。
  4. 如果 z 小于9，则在当前空白位置 (x, y) 放置数字2；如果 z 等于9，则放置数字4。
void put_num(int board[ROW][COL])
{
	int x = 0;
	int y = 0;
	int z = 0;
	x = rand() % ROW;
	y = rand() % COL;
	while (board[x][y] != 0)
	{
		x = rand() % ROW;
		y = rand() % COL;
	}
	z = rand() % 10;
	if (z < 9)
		board[x][y] = 2;
	else
		board[x][y] = 4;
	return;
}

简单的 2048 游戏的移动和合并操作

        上下左右四个方向的移动操作：up、down、left、right

每个函数都按照相应的方向进行移动并合并相同的数字。

在每个函数中，首先进行移动操作，然后进行合并操作，再次进行移动操作，并最后检查游戏是否可以继续进行（通过contrast(board)函数判断）。如果游戏可以继续，则调用put_num(board)函数来生成新的数字；否则直接返回。

void up(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	int x = 0;
	int y = 0;
	for (i = 0; i < ROW; i++)
	{
		//移动
		j = 0;
		y = 0;
		while (j < COL - 1 && y < COL - 1)
		{
			if (board[j][i] == 0)
			{
				for (x = j; x < ROW - 1; x++)
					board[x][i] = board[x + 1][i];
				board[ROW - 1][i] = 0;
				y++;
			}
			else
				j++;
		}
		//合并
		for (j = 0; j < COL - 1; j++)
			if (board[j][i] == board[j + 1][i] && board[j][i] != 0)
			{
				board[j][i] = board[j][i] * 2;
				board[j + 1][i] = 0;
			}
		//再次移动补空
		j = 0;
		y = 0;
		while (j < COL - 1 && y < COL - 1)
		{
			if (board[j][i] == 0)
			{
				for (x = j; x < ROW - 1; x++)
					board[x][i] = board[x + 1][i];
				board[ROW - 1][i] = 0;
				y++;
			}
			else
				j++;
		}
	}
	if (contrast(board) == 0)
		put_num(board);
	else
		return;
}

void down(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	int x = 0;
	int y = 0;
	for (i = 0; i < ROW; i++)
	{
		j = COL - 1;
		y = 0;
		while (j > 0 && y < COL - 1)
		{
			if (board[j][i] == 0)
			{
				for (x = j; x > 0; x--)
					board[x][i] = board[x - 1][i];
				board[0][i] = 0;
				y++;
			}
			else
				j--;
		}
		for (j = COL - 1; j > 0; j--)
			if (board[j][i] == board[j - 1][i] && board[j][i] != 0)
			{
				board[j][i] = board[j][i] * 2;
				board[j - 1][i] = 0;
			}
		j = COL - 1;
		y = 0;
		while (j > 0 && y < COL - 1)
		{
			if (board[j][i] == 0)
			{
				for (x = j; x > 0; x--)
					board[x][i] = board[x - 1][i];
				board[0][i] = 0;
				y++;
			}
			else
				j--;
		}
	}
	if (contrast(board) == 0)
		put_num(board);
	else
		return;
}

void left(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	int x = 0;
	int y = 0;
	for (i = 0; i < ROW; i++)
	{
		j = 0;
		y = 0;
		while (j < 3 && y < 3)
		{
			if (board[i][j] == 0)
			{
				for (x = j; x < ROW - 1; x++)
					board[i][x] = board[i][x + 1];
				board[i][COL - 1] = 0;
				y++;
			}
			else
				j++;
		}
		for (j = 0; j < 3; j++)
			if (board[i][j] == board[i][j + 1] && board[i][j] != 0)
			{
				board[i][j] = board[i][j] * 2;
				board[i][j + 1] = 0;
			}
		j = 0;
		y = 0;
		while (j < 3 && y < 3)
		{
			if (board[i][j] == 0)
			{
				for (x = j; x < ROW - 1; x++)
					board[i][x] = board[i][x + 1];
				board[i][COL - 1] = 0;
				y++;
			}
			else
				j++;
		}
	}
	if (contrast(board) == 0)
		put_num(board);
	else
		return;
}

void right(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	int x = 0;
	int y = 0;
	for (i = 0; i < 4; i++)
	{
		j = COL - 1;
		y = 0;
		while (j > 0 && y < COL - 1)
		{
			if (board[i][j] == 0)
			{
				for (x = j; x > 0; x--)
					board[i][x] = board[i][x - 1];
				board[i][0] = 0;
				y++;
			}
			else j--;
		}
		for (j = 3; j > 0; j--)
			if (board[i][j] == board[i][j - 1] && board[i][j] != 0)
			{
				board[i][j] = board[i][j] * 2;
				board[i][j - 1] = 0;
			}
		j = COL - 1;
		y = 0;
		while (j > 0 && y < COL - 1)
		{
			if (board[i][j] == 0)
			{
				for (x = j; x > 0; x--)
					board[i][x] = board[i][x - 1];
				board[i][0] = 0;
				y++;
			}
			else j--;
		}
	}
	if (contrast(board) == 0)
		put_num(board);
	else
		return;
}

判断在 2048 游戏中是否无法继续移动

  1. 游戏板上还有空格（值为0），即游戏可以继续；
  2. 相邻的方块（上下或左右相邻）有相同的值，即游戏可以继续合并。

如果以上任意情况成立，函数将返回0，表示游戏可以继续；否则，如果所有方块都被填满且没有相邻方块的值相同，函数将返回1，表示游戏无法继续移动，游戏结束。

 

int is_fail(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	for (i = 0; i < ROW; i++)
	{
		for (j = 0; j < COL; j++)
		{
			if (board[i][j] == 0)
				return 0;
			if (i > 0)
			{
				if (board[i - 1][j] == board[i][j])
					return 0;
			}
			if (j > 0)
			{
				if (board[i][j - 1] == board[i][j])
					return 0;
			}
		}
	}
	return 1;
}

检查在2048游戏中是否获胜

该函数遍历整个游戏板，找到其中的最大值。如果最大值达到或超过2048，函数将返回1，表示玩家已经获胜；否则返回0，表示游戏尚未获胜。

在2048游戏中，玩家的目标是通过合并方块使得其中一个方块的值达到2048。一旦某个方块的值达到2048，玩家就获胜了。

这个函数的作用是在每一步移动后检查游戏是否已经达到了获胜条件。如果返回1，通常会触发游戏获胜的逻辑，比如显示获胜信息或者终止游戏等。

int is_win(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	int num = 0;
	for (i = 0; i < ROW; i++)
		for (j = 0; j < COL; j++)
		{
			if (board[i][j] > num)
				num = board[i][j];
		}
	if (num >= 2048)
		return 1;
	else
		return 0;
}

        copyboard 函数的作用是将一个二维数组 board 中的元素复制到另一个二维数组 copy 中。通常在编程中，这样的函数用于保存一个数组的副本，以便后续的比较或者其他操作而不影响原始数组。

void copyboard(int board[ROW][COL], int copy[ROW][COL])
{
	int i = 0;
	int j = 0;
	for (i = 0; i < ROW; i++)
		for (j = 0; j < COL; j++)
			copy[i][j] = board[i][j];
}

菜单功能：

void menu()
{
	printf("**************************\n");
	printf("**************************\n");
	printf("**************************\n");
	printf("*****按 1 开 始 游 戏*****\n");
	printf("*****按 0 退 出 游 戏*****\n");
	printf("**************************\n");
	printf("**************************\n");
	printf("**************************\n");
}

主函数：

int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game2048();

			break;
		case 0:
			printf("退出游戏)\n");
			break;
		default:
			printf("再次进入游戏\n");
			break;
		}
	} while (input);
	return 0;
}

完整代码：

        Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "game2048.h"

void menu()
{
	printf("**************************\n");
	printf("**************************\n");
	printf("**************************\n");
	printf("*****按 1 开 始 游 戏*****\n");
	printf("*****按 0 退 出 游 戏*****\n");
	printf("**************************\n");
	printf("**************************\n");
	printf("**************************\n");
}

void game2048()
{
	int board[ROW][COL] = { {0} };
	int control = 0;
	DisplayBoard(board);
	init_num(board);
	system("cls"); //清屏，美观界面
	DisplayBoard(board);
	while ((control = _getch()) != 0x1b)
	{
		switch (control)
		{
		case 0xe0:
			switch (control = getch())
			{
			case 72:
				copyboard(board, copy);
				up(board);
				break;
			case 80:
				copyboard(board, copy);
				down(board);
				break;
			case 75:
				copyboard(board, copy);
				left(board);
				break;
			case 77:
				copyboard(board, copy);
				right(board);
				break;
			default:
				break;
			}

			system("cls");
			DisplayBoard(board);
			if (is_win(board) == 1)
			{
				printf("恭喜你赢了！\n");
			}
			if (is_fail(board) == 1)
			{
				printf("抱歉,您未能通关\n");
			}
		}
	}
}

int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game2048();

			break;
		case 0:
			printf("退出游戏)\n");
			break;
		default:
			printf("再次进入游戏\n");
			break;
		}
	} while (input);
	return 0;
}

game.c

#define _CRT_SECURE_NO_WARNINGS 1
#define _CRT_SECURE_NO_WARNINGS 1
#include "game2048.h"

void DisplayBoard(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	printf("tip：*方向键控制方块移动*ESC键返回菜单*\n");
	for (int j = 0; j < COL; j++)
		printf("+-----");
	printf("+\n");
	for (int i = 0; i < ROW; i++)
	{
		for (int j = 0; j < COL; j++)
		{
			printf("|");
			if (board[i][j] != 0)
				printf("%5d", board[i][j]);

			else
				printf("     ");
		}
		printf("|\n");
		for (int j = 0; j < COL; j++)
		{
			printf("+-----");
		}
		printf("+\n");
	}
}

void init_num(int board[ROW][COL])
{
	int x, y;
	x = rand() % ROW;
	y = rand() % COL;
	board[x][y] = 2;//随机在一个位置生成2
	x = rand() % ROW;
	y = rand() % COL;
	while (board[x][y] == 2)
	{
		x = rand() % ROW;
		y = rand() % COL;
	}
	board[x][y] = 2;
	return;
}

void put_num(int board[ROW][COL])
{
	int x = 0;
	int y = 0;
	int z = 0;
	x = rand() % ROW;
	y = rand() % COL;
	while (board[x][y] != 0)
	{
		x = rand() % ROW;
		y = rand() % COL;
	}
	z = rand() % 10;
	if (z < 9)
		board[x][y] = 2;
	else
		board[x][y] = 4;
	return;
}

void up(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	int x = 0;
	int y = 0;
	for (i = 0; i < ROW; i++)
	{
		//移动
		j = 0;
		y = 0;
		while (j < COL - 1 && y < COL - 1)
		{
			if (board[j][i] == 0)
			{
				for (x = j; x < ROW - 1; x++)
					board[x][i] = board[x + 1][i];
				board[ROW - 1][i] = 0;
				y++;
			}
			else
				j++;
		}
		//合并
		for (j = 0; j < COL - 1; j++)
			if (board[j][i] == board[j + 1][i] && board[j][i] != 0)
			{
				board[j][i] = board[j][i] * 2;
				board[j + 1][i] = 0;
			}
		//再次移动补空
		j = 0;
		y = 0;
		while (j < COL - 1 && y < COL - 1)
		{
			if (board[j][i] == 0)
			{
				for (x = j; x < ROW - 1; x++)
					board[x][i] = board[x + 1][i];
				board[ROW - 1][i] = 0;
				y++;
			}
			else
				j++;
		}
	}
	if (contrast(board) == 0)
		put_num(board);
	else
		return;
}

void down(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	int x = 0;
	int y = 0;
	for (i = 0; i < ROW; i++)
	{
		j = COL - 1;
		y = 0;
		while (j > 0 && y < COL - 1)
		{
			if (board[j][i] == 0)
			{
				for (x = j; x > 0; x--)
					board[x][i] = board[x - 1][i];
				board[0][i] = 0;
				y++;
			}
			else
				j--;
		}
		for (j = COL - 1; j > 0; j--)
			if (board[j][i] == board[j - 1][i] && board[j][i] != 0)
			{
				board[j][i] = board[j][i] * 2;
				board[j - 1][i] = 0;
			}
		j = COL - 1;
		y = 0;
		while (j > 0 && y < COL - 1)
		{
			if (board[j][i] == 0)
			{
				for (x = j; x > 0; x--)
					board[x][i] = board[x - 1][i];
				board[0][i] = 0;
				y++;
			}
			else
				j--;
		}
	}
	if (contrast(board) == 0)
		put_num(board);
	else
		return;
}

void left(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	int x = 0;
	int y = 0;
	for (i = 0; i < ROW; i++)
	{
		j = 0;
		y = 0;
		while (j < 3 && y < 3)
		{
			if (board[i][j] == 0)
			{
				for (x = j; x < ROW - 1; x++)
					board[i][x] = board[i][x + 1];
				board[i][COL - 1] = 0;
				y++;
			}
			else
				j++;
		}
		for (j = 0; j < 3; j++)
			if (board[i][j] == board[i][j + 1] && board[i][j] != 0)
			{
				board[i][j] = board[i][j] * 2;
				board[i][j + 1] = 0;
			}
		j = 0;
		y = 0;
		while (j < 3 && y < 3)
		{
			if (board[i][j] == 0)
			{
				for (x = j; x < ROW - 1; x++)
					board[i][x] = board[i][x + 1];
				board[i][COL - 1] = 0;
				y++;
			}
			else
				j++;
		}
	}
	if (contrast(board) == 0)
		put_num(board);
	else
		return;
}

void right(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	int x = 0;
	int y = 0;
	for (i = 0; i < 4; i++)
	{
		j = COL - 1;
		y = 0;
		while (j > 0 && y < COL - 1)
		{
			if (board[i][j] == 0)
			{
				for (x = j; x > 0; x--)
					board[i][x] = board[i][x - 1];
				board[i][0] = 0;
				y++;
			}
			else j--;
		}
		for (j = 3; j > 0; j--)
			if (board[i][j] == board[i][j - 1] && board[i][j] != 0)
			{
				board[i][j] = board[i][j] * 2;
				board[i][j - 1] = 0;
			}
		j = COL - 1;
		y = 0;
		while (j > 0 && y < COL - 1)
		{
			if (board[i][j] == 0)
			{
				for (x = j; x > 0; x--)
					board[i][x] = board[i][x - 1];
				board[i][0] = 0;
				y++;
			}
			else j--;
		}
	}
	if (contrast(board) == 0)
		put_num(board);
	else
		return;
}

int is_fail(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	for (i = 0; i < ROW; i++)
	{
		for (j = 0; j < COL; j++)
		{
			if (board[i][j] == 0)
				return 0;
			if (i > 0)
			{
				if (board[i - 1][j] == board[i][j])
					return 0;
			}
			if (j > 0)
			{
				if (board[i][j - 1] == board[i][j])
					return 0;
			}
		}
	}
	return 1;
}

int is_win(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	int num = 0;
	for (i = 0; i < ROW; i++)
		for (j = 0; j < COL; j++)
		{
			if (board[i][j] > num)
				num = board[i][j];
		}
	if (num >= 2048)
		return 1;
	else
		return 0;
}

void copyboard(int board[ROW][COL], int copy[ROW][COL])
{
	int i = 0;
	int j = 0;
	for (i = 0; i < ROW; i++)
		for (j = 0; j < COL; j++)
			copy[i][j] = board[i][j];
}

int contrast(int board[ROW][COL])
{
	int i = 0;
	int j = 0;
	for (i = 0; i < 4; i++)
		for (j = 0; j < 4; j++)
			if (copy[i][j] != board[i][j])
				return 0;
	return 1;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1565394.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

supersqli-攻防世界

supersqli-攻防世界

题目 加个报错 1 and 11 #没报错判断为单引号字符注入 爆显位 1 order by 2#回显正常 1 order by 3#报错 说明列数是2 尝试联合查询 -1 union select 1,2# 被过滤了 return preg_match("/select|update|delete|drop|insert|where|\./i",$inject); select|update|d…
阅读更多...
vCenter Server出现no healthy upstream的解决方法

vCenter Server出现no healthy upstream的解决方法

https://blog.51cto.com/wangchunhai/4907250 访问vCenter 7.0 地址后&#xff0c;页面出现“no healthy upstream”,无法正常登录vCenter&#xff0c;重启后依旧如此&#xff0c;该故障的前提是没有对vCenter做过任何配置&#xff0c;如下图所示。 尝试登录"VMware vCen…
阅读更多...
快速排渣器与矿用快速除渣器

快速排渣器与矿用快速除渣器

你不想虚度光阴&#xff0c;你想用自己的努力&#xff0c;书写自己人生的精彩&#xff0c;那么&#xff0c;你脚下的路不能回头&#xff0c;铺满掌声和鲜花的人生路上&#xff0c;脚下没有那么平坦&#xff0c;或是泥泞&#xff0c;或是陷阱&#xff0c;别管多么艰难的路程&…
阅读更多...
前端跨页面通信方案介绍

前端跨页面通信方案介绍

在浏览器中&#xff0c;我们可以同时打开多个Tab页&#xff0c;每个Tab页可以粗略理解为一个“独立”的运行环境&#xff0c;即使是全局对象也不会在多个Tab间共享。然而有些时候&#xff0c;我们希望能在这些“独立”的Tab页面之间同步页面的数据、信息或状态。这就是本文说说…
阅读更多...
ubuntu20.04 运行 lio-sam 流程记录

ubuntu20.04 运行 lio-sam 流程记录

ubuntu20.04 运行 lio-sam 一、安装和编译1.1、安装 ROS11.2、安装 gtsam1.3、安装依赖1.4、下载源码1.5、修改文件1.6、编译和运行 二、官方数据集的运行2.1、casual_walk_2.bag2.2、outdoor.bag、west.bag2.3、park.bag 三、一些比较好的参考链接 记录流程&#xff0c;方便自…
阅读更多...
新质生产力崛起，运营商前端运营如何跃升

新质生产力崛起，运营商前端运营如何跃升

“新质生产力”一个当前的热搜高频词&#xff0c;今年还被首次写进政府工作报告&#xff0c;是2024年十大工作任务的首位。那么什么是“新质生产力”&#xff1f;它对于我们的生活、学习、工作及未来发展有什么影响呢&#xff1f;今天小宝就抛砖引玉来讲一讲“新质生产力”对于…
阅读更多...
数字化服务升级：数字乡村改善农民生活质量

数字化服务升级：数字乡村改善农民生活质量

随着信息技术的迅猛发展&#xff0c;数字化浪潮已经深入社会的各个角落&#xff0c;为人们的生活带来了翻天覆地的变化。在乡村地区&#xff0c;数字化服务的升级正在逐步改变农民的生活方式&#xff0c;提高他们的生活质量。本文将围绕数字化服务升级&#xff0c;探讨数字乡村…
阅读更多...
【精心整理】2024最新Web安全攻防教程资料PPT大合集

【精心整理】2024最新Web安全攻防教程资料PPT大合集

以下是学习资料目录&#xff0c;如需要下载&#xff0c;请您前往星球查阅和获取&#xff1a;https://t.zsxq.com/18YLzWtDI 1、Sqlmap Tamper脚本编写介绍-01.pptx 2、Tamper脚本分析&#xff08;支持所有类型数据库的Tamper脚本&#xff09;-01.pptx 3 、Sqlmap Tamper脚本分析…
阅读更多...
一款强大的逆向分析工具-Ghidra

一款强大的逆向分析工具-Ghidra

工具介绍 Ghidra 是由美国国家安全局&#xff08;NSA&#xff09;研究部门开发的软件逆向工程&#xff08;SRE&#xff09;套件&#xff0c;用于支持网络安全任务。包括一套功能齐全的高端软件分析工具&#xff0c;使用户能够在各种平台(Windows、Mac OS和Linux)分析编译后的代…
阅读更多...
Flutter应用发布流程详解：从开发到上架一站式指南

Flutter应用发布流程详解：从开发到上架一站式指南

引言 Flutter是一款由Google推出的跨平台移动应用开发框架&#xff0c;其强大的性能和流畅的用户体验使其备受开发者青睐。然而&#xff0c;开发一款应用只是第一步&#xff0c;将其成功上架到苹果商店才是实现商业目标的关键一步。本文将详细介绍如何使用Flutter将应用程序上…
阅读更多...
Qt使用opencv打开摄像头

Qt使用opencv打开摄像头

1.效果图 2.代码 #include "widget.h"#include <QApplication>#include <opencv2/core/core.hpp> #include <opencv2/highgui/highgui.hpp> #include <opencv2/imgproc/imgproc.hpp>#include <QImage> #include <QLabel> #incl…
阅读更多...
为什么蓝牙信道探测将引领高精度定位服务？

为什么蓝牙信道探测将引领高精度定位服务？

从蓝牙耳机到智能家居设备&#xff0c;蓝牙技术因其成熟的音频流和数据传输功能已成为我们生活中的一部分。一项新技术——蓝牙信道探测&#xff08;Bluetooth Channel Sounding&#xff09;正向高精度定位服务市场迈进。 本文信驰达&#xff08;RF-star&#xff09;将介绍蓝牙…
阅读更多...
java学习之路-数组定义与使用

java学习之路-数组定义与使用

目录 ​编辑 1.什么是数组 2.数组的创建及其初始化 2.1数组的创建 2.2数组的初始化 3.数组的使用 3.1数组元素访问 3.2遍历数组 4.数组是引用类型 4.1jvm的内存分布 4.2基本类型变量与引用类型变量的区别 4.3引用变量详解 4.4 null 5.数组的使用场景 5.1存储数据 5…
阅读更多...
基于SpringBoot+微信小程序的图书借阅管理系统（包运行调试）

基于SpringBoot+微信小程序的图书借阅管理系统（包运行调试）

介绍 系统介绍 是一套图书借阅管理系统&#xff0c;包括用户小程序以及后台管理系统。 前台商城系统包含用户注册登录、首页门户、图书查询、在线借阅、个人中心、我的信息、我的借阅、押金充值。 后台管理系统包含统计分析、用户管理、分类管理、图书管理、借阅管理、管理员…
阅读更多...
硬件了解 笔记

硬件了解 笔记

motherboard的高低端区别在哪里&#xff1f; 核心&#xff1a;从单核变成双核&#xff0c;多核&#xff08;几核就是几个打工人&#xff09; 多线程&#xff1a;6核本来对应6个线程&#xff0c;但是多线程就是说6核对应12个线程 频率 主频&#xff1a;平时打工的速度 睿频&…
阅读更多...
图书馆信息管理系统（项目测试）

图书馆信息管理系统（项目测试）

图书馆管理系统系统分析与设计 图书馆信息管理系统&#xff08;项目需求和计划、项目设计&#xff09; 图书馆信息管理系统&#xff08;项目实现&#xff09; 图书馆信息管理系统&#xff08;项目测试&#xff09; 图书馆信息管理系统&#xff08;总&#xff09; 目录 一、项目…
阅读更多...
【SQL Server】1. 认识+使用

【SQL Server】1. 认识+使用

1. 创建数据库的默认存储路径 C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Microsoft SQL Server 2008 R2 当我们选择删除数据库时&#xff0c;对应路径下的文件也就删除了 2. 导入导出数据工具的路径 3. 注册数据库遇到的问题 ??? 目前的问题就是服务器新建…
阅读更多...
赛氪网在长沙宣布启动“徽文化外宣翻译大赛”

赛氪网在长沙宣布启动“徽文化外宣翻译大赛”

2024年3月30日下午&#xff0c;在美丽的星城长沙&#xff0c;赛氪网作为承办方&#xff0c;在中国翻译协会年会期间成功举办了备受瞩目的“AI科技时代竞赛与就业分论坛”。此次论坛汇聚了众多翻译界、科技界和教育界的专家学者&#xff0c;共同就科技、实践、就业与竞赛人才培养…
阅读更多...
LabVIEW齿轮箱噪声监测系统

LabVIEW齿轮箱噪声监测系统

LabVIEW齿轮箱噪声监测系统 齿轮箱作为机械设备的“心脏”&#xff0c;其健康状态对设备的性能有着重要的影响。传统的齿轮箱监测方法依赖于直接的振动信号分析&#xff0c;但这种方法不仅成本高昂&#xff0c;而且在安装和拆卸过程中可能对设备造成损害。针对这些问题&#x…
阅读更多...
在 Langchain 中使用 RAPTOR 实现高级 RAG

在 Langchain 中使用 RAPTOR 实现高级 RAG

RAPTOR&#xff1a;树结构的索引和检索系统的递归抽象处理-CSDN博客 原文地址&#xff1a;implementing-advanced-rag-in-langchain-using-raptor 2024 年 3 月 24 日 RAPTOR 简介 递归抽象处理树组织检索(RAPTOR)是种全新而强大的索引和检索技术&#xff0c;它全面适用于L…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023