C++版俄罗斯方块

最新推荐文章于 2023-07-20 14:30:14 发布
最新推荐文章于 2023-07-20 14:30:14 发布
阅读量1.1k 收藏 7
点赞数 1
分类专栏： C语言 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AppWhite_Star/article/details/122072203
版权

1.俄罗斯方块

主入口
 
#include <iostream>
#include <Windows.h>
#include <conio.h>

using namespace std;

#include "CGame.h"

int main(){
#if 0
	// 方块测试
	CBlock block;
	block.CreateBlock();
	block.RotateBlock();
	block.RotateBlock();
	block.RotateBlock();
	block.RotateBlock();
	block.RotateBlock();
	block.RotateBlock();
	block.RotateBlock();
	block.RotateBlock();
	block.CreateBlock();
#endif // 0
#if 0
	// 背景测试
	CBackground bg;
	bg.InitBk();
	bg.RemoveRows();
#endif // 0

	CGame game;
	game.InitGame();
	game.ShowGame();
	// 控制方块 直到游戏结束
	while (1) { // 是否有键盘输入
		int nRet = _kbhit();
		if (nRet != 0) {
			char nKey = _getch(); // 有键盘输入 获取按下的值
			switch (nKey) {
				// 上
			case 'W':
			case 'w':
				game.MoveUp();
				break;
				// 下
			case 'S':
			case 's':
				game.MoveDown();
				break;
				// 左
			case 'A':
			case 'a':
				game.MoveLeft();
				break;
				// 右
			case 'D':
			case 'd':
				game.MoveRight();
				break;
			}
			// 每次操作完之后再显示界面
			game.ShowGame();
		}
	}
	system("pause");
	return 0;
}

方块封装
    
#pragma once

#define BLOCK_ROW 4 // 方块有几行
#define BLOCK_COL 4 // 方块有几列

/*
	对方块进行封装
*/
class CBlock
{
public:
	CBlock();
	~CBlock();
	void CreateBlock(); // 创建一个方块
	void RotateBlock(); // 旋转方块

	int GetIdx() const;
	void SetIdx(int idx);

	// 创建一个指向BLOCK_COL列的二维数组指针
	typedef char(*PBLOCkDATA)[BLOCK_COL];
	// 返回方块的数据
	const PBLOCkDATA GetBlockData() const;

private:
	char m_aryBlock[BLOCK_ROW][BLOCK_COL];// 方块的数组 每个方块都是四行四列
	int m_nType; // 方块的类型
	int m_nIdex; // 方块类型中的第几个形态
};

#include "CBlock.h"
#include <time.h>
#include <stdlib.h>
#include <string.h>

#define BLOCK_SIZE 16 // 每个方块的每个类型是16个字节大小
#define BLOCK_TYPE_COUNT 4 // 每种方块有四个类型
// 总共就是 每个方块占 BLOCK_SIZE * BLOCK_TYPE_COUNT 64 个字节

#define BLOCK_TYPE_ROW_COUNT 16 // 每种方块在大数组中占16行

/*
	每个方块
	和每个方块对应的四种形态
	二维数组
	每四行代表一个方块的形态
	每十六行代表一个方块的四种形态
*/
static char g_uchBlocks[][BLOCK_COL] = {
	/*
		■■ ■■■■    ■   ■■■
		■■           ■■■     ■
		1代表方块 0代表空格
		每个方块有四种形状
	*/
	/*
		■■
		■■
	*/
	1,1,0,0,
	1,1,0,0,
	0,0,0,0,
	0,0,0,0,

	1,1,0,0,
	1,1,0,0,
	0,0,0,0,
	0,0,0,0,

	1,1,0,0,
	1,1,0,0,
	0,0,0,0,
	0,0,0,0,

	1,1,0,0,
	1,1,0,0,
	0,0,0,0,
	0,0,0,0,
	/*
		■■■■
	*/
	1,1,1,1,
	0,0,0,0,
	0,0,0,0,
	0,0,0,0,

	1,0,0,0,
	1,0,0,0,
	1,0,0,0,
	1,0,0,0,

	1,1,1,1,
	0,0,0,0,
	0,0,0,0,
	0,0,0,0,

	1,0,0,0,
	1,0,0,0,
	1,0,0,0,
	1,0,0,0,

	/*
		  ■
		■■■
	*/
	0,1,0,0,
	1,1,1,0,
	0,0,0,0,
	0,0,0,0,

	0,1,0,0,
	1,1,0,0,
	0,1,0,0,
	0,0,0,0,

	1,1,1,0,
	0,1,0,0,
	0,0,0,0,
	0,0,0,0,

	0,1,0,0,
	0,1,1,0,
	0,1,0,0,
	0,0,0,0,

	/*
		■■■
			■
	*/
	1,1,1,0,
	0,0,1,0,
	0,0,0,0,
	0,0,0,0,

	0,1,0,0,
	0,1,0,0,
	1,1,0,0,
	0,0,0,0,

	1,0,0,0,
	1,1,1,0,
	0,0,0,0,
	0,0,0,0,

	1,1,0,0,
	1,0,0,0,
	1,0,0,0,
	0,0,0,0
};

CBlock::CBlock()
{
	// 初始化时间种子
	srand((unsigned)time(NULL));
}

CBlock::~CBlock()
{
}

// 创建一个方块
void CBlock::CreateBlock()
{
	/*
		int m_nType; // 方块的类型
		int m_nIdex; // 方块类型中的第几个形态
	*/
	// 大数组中有四类
	// 二维数组总的字节 / 64 就是有多少种类型的方块 一个方块64字节
	this->m_nType = rand() % (sizeof(g_uchBlocks) / (BLOCK_TYPE_COUNT * BLOCK_SIZE));
	// 每一类有四个形态 那么对4取模 就是 0 - 3 0 代表第一种
	this->m_nIdex = rand() % BLOCK_TYPE_COUNT;
	// 拷贝方块的数据
	memcpy_s(this->m_aryBlock,
		sizeof(this->m_aryBlock),
		&g_uchBlocks[this->m_nType*BLOCK_TYPE_ROW_COUNT + this->m_nIdex* BLOCK_TYPE_COUNT][0],
		sizeof(this->m_aryBlock));
}

// 旋转方块
void CBlock::RotateBlock()
{
	++(this->m_nIdex); // 直接形态+1
	if(this->m_nIdex >= BLOCK_TYPE_COUNT){ // 如果形态已经不是术语当前方块的量
		this->m_nIdex = 0; // 那么就为
	}
	// 重新拷贝方块数据 完成旋转
	memcpy_s(this->m_aryBlock,
		sizeof(this->m_aryBlock),
		&g_uchBlocks[this->m_nType * BLOCK_TYPE_ROW_COUNT + this->m_nIdex * BLOCK_TYPE_COUNT][0],
		sizeof(this->m_aryBlock));
}

int CBlock::GetIdx() const
{
	return this->m_nIdex;
}

void CBlock::SetIdx(int idx)
{
	this->m_nIdex = idx;
	// 重新拷贝方块数据 恢复旋转之前的状态
	memcpy_s(this->m_aryBlock,
		sizeof(this->m_aryBlock),
		&g_uchBlocks[this->m_nType * BLOCK_TYPE_ROW_COUNT + this->m_nIdex * BLOCK_TYPE_COUNT][0],
		sizeof(this->m_aryBlock));
}

/*
	返回方块的数据
*/
const CBlock::PBLOCkDATA CBlock::GetBlockData() const
{
	return (PBLOCkDATA)this->m_aryBlock;
}


背景封装
  
#pragma once
#include "CBlock.h"

#define BK_ROW 12 // 背景的行数
#define BK_COL 16 // 背景的列数

#define WALL 1 // 标志，墙
#define SPACE 0 // 标志 非墙

/*
	背景墙
*/
class CBackground
{
public:
	CBackground();
	~CBackground();
	// 初始化背景墙
	void InitBk();
	// 消除行数 返回消除了多少行
	int RemoveRows(); 
	// 固定方块  方块所在坐标
	void FixedBlock(const CBlock &block,size_t nRow,size_t nCol);
	// 清除原来的方块
	void ClearBlock(const CBlock& block, size_t nRow, size_t nCol);

	// 定义一个拥有BK_COL列的二维数组指针 名字叫做 BKDATA
	typedef unsigned char (*BKDATA)[BK_COL];

	// 返回当前背景的二维数组指针
	const BKDATA GetBkData() const;

private:
	bool IsCanRemove(size_t nRow); // 此行是否可以消除
	void RemoveRow(size_t nRow); // 消除行
private:
	unsigned char m_aryBkData[BK_ROW][BK_COL];
};

#include "CBackground.h"
#include <iostream>
#include <stdlib.h>
#include <string.h>

using namespace std;

CBackground::CBackground()
{
}

CBackground::~CBackground()
{
}

/*
	初始化背景墙
*/
void CBackground::InitBk()
{
	for (size_t nRow = 0; nRow < BK_ROW; nRow++){
		for(size_t nCol = 0; nCol < BK_COL; nCol++){
			// 如果是左右边界 或者 下边界 才是方块
			if (nCol == 0 || nCol == BK_COL - 1 || nRow == BK_ROW - 1){
				this->m_aryBkData[nRow][nCol] = WALL; // 墙
			}else{
				this->m_aryBkData[nRow][nCol] = SPACE; // 非墙
			}
		}
	}
}

const CBackground::BKDATA CBackground::GetBkData() const
{
	return (BKDATA)this->m_aryBkData;
}

/*
	此行是否可以消除
*/
bool CBackground::IsCanRemove(size_t nRow)
{
	/*
		从第二列开始到倒数第二列
	*/
	for (size_t nCol = 1; nCol < BK_COL - 1; nCol++) {
		if (this->m_aryBkData[nRow][nCol] == SPACE){
			// 如果这一行里面有一个是空白 那么就证明这一行不是全部为方块了
			// 所以这里直接return 就好了
			return false;
		}
	}
	// 如果前面一行都遍历完了还没有return 就证明这一行都是墙壁 那么久可以return true了
	// 证明这一行可以消除
	return true;
}

/*
	 消除行
*/
void CBackground::RemoveRow(size_t nRow)
{
	/*
		从当前这行可以被消除的行开始向上复制
	*/
	for (size_t i = nRow ; i > 0; i--) {
		/*
			从这一行开始每次向上拷贝一行下来覆盖当前的数据
			直至第二行 即i = 1的时候也拷贝 
			i = 0 第一行 就不拷贝了
		*/
		memcpy_s(&this->m_aryBkData[i][0],
			BK_COL,
			&m_aryBkData[i-1][0],
			BK_COL);
	}
}

/*
	消行
*/
int CBackground::RemoveRows()
{
	int removeRow = 0;
	/*
		从最后一行 非墙的位置 往上遍历 逐行判断是否可以消行
	*/
	for (size_t nRow = BK_ROW - 2; nRow > 0;) {
		// 每一行都去判断是否可以消除
		if(IsCanRemove(nRow)){
			// 如果可以消的话
			// 从要被消除的这行开始 要把上面的复制下来
			RemoveRow(nRow); // 消除此行
			removeRow++; // 每次消除一行计数+1
		}else{
			// 因为删除之后 当前行就是上一行了 不需要再--
			// 只有当这一行没被删除的时候 我们才继续向上扫描
			nRow--;
		}
	}
	return removeRow;
}

/*
	固定方块 其实就是变为了墙壁
	其实就是把方块的数据拷贝到背景墙中
	
	方块所在坐标 行和列
*/
void CBackground::FixedBlock(const CBlock& block,size_t nRow, size_t nCol)
{

	CBlock::PBLOCkDATA pBlockData = block.GetBlockData();
	/*
		将方块的数据写入到背景墙
	*/
	for (size_t i = 0; i < BLOCK_ROW; i++) {
		for (size_t j = 0; j < BLOCK_COL; j++) {
			// 如果是为1
			if(pBlockData[i][j] == WALL){ // 找出四行四列中是为方块的坐标
				// 写入到大数组中
				// 从当前的行数开始遍历四行 从当前的列数开始遍历四列

				this->m_aryBkData[nRow+i][nCol+j] = pBlockData[i][j];
			}
		}
	}
}
/*
	清除原来的方块
*/
void CBackground::ClearBlock(const CBlock& block, size_t nRow, size_t nCol)
{
	// 获取当前方块
	CBlock::PBLOCkDATA pBlockData = block.GetBlockData();
	/*
		将方块的数据写入到背景墙
	*/
	for (size_t i = 0; i < BLOCK_ROW; i++) {
		for (size_t j = 0; j < BLOCK_COL; j++) {
			// 如果是为1
			if (pBlockData[i][j] == WALL) { // 找出四行四列中是为方块的坐标
				// 写入到大数组中
				// 从当前的行数开始遍历四行 从当前的列数开始遍历四列
				// 把当前为1的墙壁修改为空格
				this->m_aryBkData[nRow + i][nCol + j] = SPACE;
			}
		}
	}
}


控制封装
    
#pragma once
#include "CBackground.h"
#include "CBlock.h"
/*
	游戏的操作逻辑
*/
class CGame
{
public:
	CGame();
	~CGame();
	// 初始化游戏
	void InitGame();
	// 显示游戏
	void ShowGame();
	// 移动方块
	void MoveLeft();
	void MoveRight();
	void MoveDown();
	void MoveUp();

private:
	bool IsCanMove(); // 是否可以移动

private:
	CBlock m_block; // 持有方块
	CBackground m_bk; // 持有背景
	size_t m_nRow; // 方块的x坐标
	size_t m_nCol; // 方块的y坐标
};

#include "CGame.h"
#include <stdlib.h>
#include <iostream>

using namespace std;

CGame::CGame()
{
}

CGame::~CGame()
{
}

/*
	初始化游戏
*/
void CGame::InitGame()
{
	/*
		初始化背景
		初始化方块
		初始化方块的坐标
	*/
	this->m_bk.InitBk(); // 把背景左右两边和下面初始化为墙壁 
	this->m_block.CreateBlock(); // 挑选出方块的类型和形态写入方块数组中
	this->m_nRow = 0; // 默认方块所在的行是第0行
	this->m_nCol = BK_COL / 2 - 2; // 默认方块所在的位置是正中间

	// 游戏一开始就显示一个方块在正中间
	/*
		通过方块对象获取方块的小数组遍历，
		根据当前方块的坐标
		把当前方块加入到大数组中
	*/
	this->m_bk.FixedBlock(this->m_block,m_nRow,m_nCol);
}

/*
	 显示游戏
*/
void CGame::ShowGame()
{
	// 清除屏幕
	system("cls");
	// 获取背景数据
	/*
		因为我们已经把小方块的数据写入到背景中了
		这个时候小方块所在的位置也是墙壁了
		所以我们直接遍历整个大数组显示就好了
	*/
	CBackground::BKDATA pData = this->m_bk.GetBkData();
	// 开始显示
	for (size_t nRow = 0; nRow < BK_ROW; nRow++) {
		for (size_t nCol = 0; nCol < BK_COL; nCol++) {
			// 如果是墙壁
			if(pData[nRow][nCol] == WALL){
				cout << "■";
			}else{
				cout << "  ";
			}
		}
		cout << endl;
	}
}

/*
	向左移动
*/
void CGame::MoveLeft()
{
	/*
		先进行清除原来的方块
	*/
	this->m_bk.ClearBlock(this->m_block, this->m_nRow, this->m_nCol);
	/*
		因为在初始化的时候我们就已经保存了方块的初始坐标
		和已经把方块固定到大背景中了 所以这里可以直接进行操作了
	*/
	this->m_nCol--; // 列数--
	// 如果撞到墙壁了
	if (!IsCanMove()) { // 如果不能移动
		this->m_nCol++;
	}
	
	/*
		清除原来的方块位置
		移动完以后
		重新将方块写入到背景中【即股东】
	*/
	this->m_bk.FixedBlock(this->m_block, this->m_nRow, this->m_nCol);
}

/*
	向右移动
*/
void CGame::MoveRight()
{
	/*
		先进行清除原来的方块
	*/
	this->m_bk.ClearBlock(this->m_block, this->m_nRow, this->m_nCol);
	/*
		因为在初始化的时候我们就已经保存了方块的初始坐标
		和已经把方块固定到大背景中了 所以这里可以直接进行操作了
	*/
	this->m_nCol++; // 列数++
	// 如果撞到墙壁了
	if (!IsCanMove()) { // 如果不能移动
		this->m_nCol--;
	}
	/*
		清除原来的方块位置
		移动完以后
		重新将方块写入到背景中【即股东】
	*/
	this->m_bk.FixedBlock(this->m_block, this->m_nRow, this->m_nCol);
}

/*
	向下移动
*/
void CGame::MoveDown()
{
	/*
		先进行清除原来的方块
	*/
	this->m_bk.ClearBlock(this->m_block, this->m_nRow, this->m_nCol);
	/*
		因为在初始化的时候我们就已经保存了方块的初始坐标
		和已经把方块固定到大背景中了 所以这里可以直接进行操作了
	*/
	this->m_nRow++; // 行数++
	if(!IsCanMove()){ // 如果不能移动
		this->m_nRow--;

		// 向下不能移动了 固定住
		this->m_bk.FixedBlock(this->m_block, this->m_nRow, this->m_nCol);

		// 产生新的方块
		this->m_block.CreateBlock(); // 挑选出方块的类型和形态写入方块数组中
		this->m_nRow = 0; // 默认方块所在的行是第0行
		this->m_nCol = BK_COL / 2 - 2; // 默认方块所在的位置是正中间
		
		// 检查是否能清除
		this->m_bk.RemoveRows();
	}
	/*
		清除原来的方块位置
		移动完以后 
		重新将方块写入到背景中【即股东】 
	*/
	this->m_bk.FixedBlock(this->m_block,this->m_nRow,this->m_nCol);
}

/*
	旋转
*/
void CGame::MoveUp()
{
	/*
		先进行清除原来的方块
	*/
	this->m_bk.ClearBlock(this->m_block, this->m_nRow, this->m_nCol);
	// 旋转
	int nOldIdx = this->m_block.GetIdx(); // 获取原来旋转之前的形态
	/*
		进行旋转
		旋转会修改小方块数组对应的1和0
	*/
	this->m_block.RotateBlock();
	/*
		旋转之后进行判断 看看旋转之后的形态
		是否跟墙壁重叠了
		如果重叠的话就恢复没旋转之前的形态
	*/
	if(!IsCanMove()){
		// 如果不可以移动的话
		this->m_block.SetIdx(nOldIdx);
	}
	/*
		清除原来的方块位置
		旋转完以后
		重新将方块写入到背景中【即股东】
	*/
	this->m_bk.FixedBlock(this->m_block, this->m_nRow, this->m_nCol);

}
/*
	是否可以移动
*/
bool CGame::IsCanMove()
{	
	// 获取背景数据
	CBackground::BKDATA pData = this->m_bk.GetBkData();
	// 获取当前方块
	CBlock::PBLOCkDATA pBlockData = this->m_block.GetBlockData();
	// 循环判断
	for(size_t i = 0; i < BLOCK_ROW; i++){
		for(size_t j = 0; j < BLOCK_COL; j++){
			// 如果方块中墙壁的位置和背景的墙的位置重叠了
			/*
				如果小方块在大数组中移动到了墙壁
				并且是实心的地方移动到墙壁
			*/
			if(pData[this->m_nRow+i][this->m_nCol+j] == WALL
				&& pBlockData[i][j] == WALL){
				return false;
			}
		}
	}
	return true;
}

image-20211221200440961

Star_WPF上位机开发
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
俄罗斯方块C++源代码
09-18
功能齐全，可以保存游戏进度，根据得分自动调整难度，一次性消去多行得分有加权，可玩可学习
c/c++ 实现俄罗斯方块小游戏（附全部源码）
q841447739的博客
08-11 2万+
使用easyX库，基于c/c++，实现俄罗斯方块小游戏。（附全部源码）
用c++语言实现俄罗斯方块
weixin_42611177的博客
02-16 789
俄罗斯方块是一款经典的游戏，使用C语言实现可以考虑以下步骤： 创建游戏框架：可以使用C语言中的窗口库(如SDL或OpenGL)创建一个游戏窗口，以便显示游戏界面。 设计方块：定义俄罗斯方块的形状和颜色，可以使用二维数组表示方块的形状，每一种颜色用一个整数值表示。 控制方块移动：使用键盘输入函数来控制方块的移动、旋转等操作，并对方块进行边界检测，以避免超出游戏界面。 碰撞检测：当方块落到底部...
【C++项目实现】俄罗斯方块
Newin2020的博客
07-31 3337
📣专栏定位：为刚学完C++或还在学习C++过程中的小伙伴提供练手的项目，帮助大家快速熟悉C++语法。
俄罗斯方块c++代码附注释
Ljq0704的博客
06-01 2276
在DEVc++上把代码输进去就能立即玩啦。而且不用改文件类型之类的。
C++俄罗斯方块
YiShi's Blog
04-04 1万+
前言 一个礼拜前想做一个俄罗斯方块小游戏，因为想用c++实现，但又受制于界面，于是苦读了几天的Qt。昨天开工连带一个不眠夜，总算是大功告成，个中滋味，怕是只有自己知道。 简介 俄罗斯方块，c++，qt。 功能：常规俄罗斯方块具有的：方块旋转，左移，右移，下落加速，消行，提示下一块样式等等都已实现。同时实现了记分以及暂停的功能。 效果图游戏过程效果图暂停效果图游戏结束效果图实现思路
C++版本俄罗斯方块代码
04-15
C++版本俄罗斯方块代码,小巧，但是非常经典！vs 2015 编译通过！@
Linux下用C++实现俄罗斯方块
09-01
主要为大家详细介绍了Linux下用C++实现俄罗斯方块的相关资料，感兴趣的小伙伴们可以参考一下
C++实现俄罗斯方块游戏
09-07
主要为大家详细介绍了C++实现俄罗斯方块游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
魂斗罗游戏源码
05-14
经典怀旧游戏魂斗罗，C++编写，音效+素材+源码，可下载vs运行看效果
俄罗斯方块源代码C版/C++版各一个
02-13
俄罗斯方块-c版 使用windows的库，不需要另外的库文件 俄罗斯方块-c++版，使用了ege图形程序,可根据这个游戏，写一些其他的游戏，可扩展性强。
俄罗斯方块
12-27
俄罗斯方块。 欢迎大家一起学习。
用C++编写的简易版的俄罗斯方块小游戏
03-21
用C++语言自己写的俄罗斯方块小游戏，需要用编写C++的工具运行后才能玩，主要是想练习自己编写C++代码的能力，跟大家一起分享。
俄罗斯方块c++源代码
热门推荐
panjoel的博客
08-23 3万+
俄罗斯方块 其实这也挺简单 的 #include<iostream> #include<string> #include<ctime> #include<cstdlib> #include<windows.h> #include<conio.h> using namespace std; int block00[4][4]...
c++ 项目练习3 俄罗斯方块游戏
weixin_43528481的博客
04-19 985
3.方块类成员函数实现。
c++实现俄罗斯方块
li2013li的博客
07-20 852
以下就是俄罗斯方块的c++代码，大家可以参考。编译器里运行，其他的编译器不能。注意：这个代码只能在。
使用C/C++制作简单的俄罗斯方块 一
qq_55269856的博客
08-31 2676
本章目的是不使用外置图形库创建窗口
c++编俄罗斯方块代码
最新发布
04-15
C++编写俄罗斯方块的代码可以分为以下几个部分： 1. 方块的表示：可以使用二维数组来表示方块的形状，每个方块可以由四个小方块组成。例如，可以使用一个4x4的二维数组来表示方块的形状，其中1表示方块的一部分，0表示空白。 2. 方块的移动：可以使用键盘输入来控制方块的移动，例如按下左箭头键可以使方块向左移动，按下右箭头键可以使方块向右移动，按下下箭头键可以使方块加速下落。 3. 方块的旋转：可以使用旋转矩阵来实现方块的旋转。通过改变方块的形状数组，可以实现方块的顺时针或逆时针旋转。 4. 方块的碰撞检测：在方块下落的过程中，需要检测方块是否与其他已经存在的方块或边界发生碰撞。可以通过判断方块下方是否有其他方块或边界来进行碰撞检测。 5. 方块的消除：当一行被填满时，需要将该行消除，并将上面的方块向下移动一行。可以通过遍历每一行，检查是否满行来实现方块的消除。 以上是俄罗斯方块的基本代码结构，具体的实现方式可以根据个人的编程风格和需求进行调整和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值