操作系统课程设计 存储管理——动态分区空闲空间分配算法的模拟

最新推荐文章于 2024-07-07 17:53:44 发布
最新推荐文章于 2024-07-07 17:53:44 发布
阅读量2.2k 收藏 42
点赞数 3
分类专栏： 课程设计&实验
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40722582/article/details/103835190
版权

1. 设计合适的展示方式展示当前内存区的使用情况、空闲情况。

2. 模拟动态分区的分配过程，课本介绍的4种分配算法都需要实现（4.2.2小节下的第3点），直观的展示分配前后的情况。

3. 模拟动态分区的回收过程，根据设计使用的数据结构进行分区的前/后/前后合并，，直观的展示回收前后的情况。

 

#include<iostream>
#include<vector>
#include<cstring>
#include<string>
#include<cstdio>
#include<queue>
#include<map>
using namespace std;

map<bool, string >mp;

#define busy false
#define free true
//#define NotEnd 1 
#define End INT_MAX
#define notEnd INT_MIN 
struct zone{
	int size; //分区大小
	int start; //分区起始地址
	bool status;//分区状态 
};

struct process{
	int id;//进程号
	int start; /*进程在内存中的起始地址*/
	process(){
		start = -1;/*没调入内存的进程起始地址初始化为-1*/
	}
	int size;//进程大小
	int runTime;//进程运行时间
};
vector<zone>freeTable; //分区表
queue<process>processQueue; //进程队列
vector<process>runVector; //在内存中运行的进程

bool cmpByAddress(zone z1, zone z2){/*按起始地址排序*/
	return z1.start < z2.start; 
}

bool cmpBySmallSize(zone z1, zone z2){/*小区在前， 大区在后排列*/
	return z1.size < z2.size;
}

bool cmpByBigSize(zone z1, zone z2){/*大区在前， 小区灾后*/
	return z1.size > z2.size;
}



void initProcess(){/*初始化进程*/
	int n ; 
	cout<<"输入进程个数"<<endl;
	cin>> n;
	for(int i = 0; i < n; i++){
		process ps;
		cout<<"输入进程的id 大小 和 运行时间"<<endl;
		cin>>ps.id;
		//cout<<"输入进程的大小"<<endl;
		cin>>ps.size;
		//cout<<"输入进程的运行时间"<<endl;
		cin>>ps.runTime;

		processQueue.push(ps);
	}

	return ; 
	
}


void initMemory(){/*初始化内存分配表*/
	cout<<"输入初始内存的起始地址, 分区的大小 "<<endl;
	zone ft;
	cin>>ft.start;
	cin>>ft.size;
	//ft.id = code++;
	ft.status = free;

	freeTable.push_back(ft);
	cout<<"初始化完成"<<endl;
	return ; 


}
	

void showMemory(){/*显示内存分配表*/

	/*将内存按照起始地址从小到大的顺序排列*/
	sort(freeTable.begin(), freeTable.end(),cmpByAddress);

	int length = freeTable.size();
	
	printf("%-8s	%-8s	%-8s	%-8s\n", "分区号",
		"分区大小/KB", "分区起始地址/K", "状态");//数据左对齐输出
	//cout<<"length : "<<length<<endl;
	for(int i = 0; i <  length; i++){
		//cout<<freeTable[i].id<<'\t'<<freeTable[i].size<<'\t'<<freeTable[i].start<<'\t'<<freeTable[i].status<<endl;
		printf("%-8d	%-8d	%-8d	%-8s\n",i + 1,
			freeTable[i].size, freeTable[i].start, mp[freeTable[i].status].c_str());
	}

	return ; 
}

void releaseProcess(){/*释放进程*/
	while(true){
		bool flag = false; 
		for(int i = 0; i < runVector.size(); ){
			runVector[i].runTime--;//进程运行1个单位时间
			if(runVector[i].runTime == 0){
				//cout<<"进程"<<runVector[i].id<<"在内存中的起始地址是运行结束，释放内存了"<<endl;

				printf("进程%d 在内存的起始地址是 %dK,大小是%d KB,其现在释放内存了\n", 
					runVector[i].id, runVector[i].start, runVector[i].size);
				flag = true;
				
				/*修改分配表*/
				int lengthTable = freeTable.size();
				for(int j = 0; j < lengthTable; j++){
					//根据start 和 size 找到其在分配表的位置
					if(freeTable[j].start == runVector[i].start && freeTable[j].size == runVector[i].size){
						freeTable[j].status = free;/*修改为空闲状态*/
						break;
					}
				}

				/*将其从内存中删除，注意不能先修改分配表前删除该项*/
				vector<process>::iterator it = runVector.begin() + i;
				it = runVector.erase(it);/*记得要返回值*/
				//i无须变化，为了让这一趟的进程都做到单位时间减少1
				//break;
			}
			else 
				i++;
			
		}

		if(flag )/*这一趟有1个或多个进程释放了内存，不妨结束释放内存*/
			break;	
	}

	

	return ; 

}

/*合并空闲区*/
int  mergeMemory(){
	/*合并内存之前要按地址从小到大排序*/
	sort(freeTable.begin(), freeTable.end(), cmpByAddress);
	
	bool FLAG  = false; 
	for(int i = 0; i < freeTable.size(); i++){
		if(freeTable[i].status == busy)
			continue ; 
		bool flag = false;
		int pre = i;
		int step = pre + 1;
		/*查找i下面的空闲的分区*/
		while( (step < freeTable.size())  && (freeTable[pre].start + freeTable[pre].size == freeTable[step].start) && freeTable[step].status == free){
			flag = true; 
			FLAG = true;
			step++;/*step 和 pre 向后移动判断下一个空闲分区*/
			pre++;
		}

		for(int k = i + 1; k <= step -1; k++){/*把 i + 1 到 step - 1 的分区合并到i分区中*/
			freeTable[i].size += freeTable[k].size;

		}

		/*由于合并， 把 i + 1 到 step - 1这些分区合并了，在空闲表删除这些项*/
		vector<zone>::iterator it = freeTable.begin() + i + 1;
		for(int j =1; j <= step -1 -i ; j++){/*总共是删除step - 1-i项目*/
			it = freeTable.erase(it);
		}

		if(flag)
			i = -1;/*重新从头开始查找合并区间*/
	}

	if(FLAG)
		return 1; /*有区间合并了*/


	return 0; /*没有区间可合并*/

}


int allocateMemory(){/*除了循环适应其他都是调用这个分配内存*/
	/*开始分配内存*/
	process tmp; 
	if(processQueue.size() != 0){
		
		int length = freeTable.size();//分配表大小
		tmp = processQueue.front();//获取一个进程
		int i; 
		//cout<<"start: "<<start<<endl;
		for( i = 0 ; i < length; i++){
			
			if(freeTable[i].size < tmp.size)//分区太小
				continue; 
			//分区是空闲的且刚好足够容纳进程
			if(freeTable[i].status == free && freeTable[i].size == tmp.size){

				//cout<<"进程"<<tmp.id<<" 内存分配成功,其大小是 "<<tmp.size<<endl;
				processQueue.pop();/*进程分配内存成功， 弹出进程队列*/
				freeTable[i].status = busy;//修改分区状态
				tmp.start = freeTable[i].start;//设置进程在内存的起始地址
				runVector.push_back(tmp);/*调入内存*/

				printf("进程%d内存分配成功,其在内存的起始地址是%d,大小是%d \n",
					tmp.id, tmp.start, tmp.size);
				break; //分配成功，不用继续查找分配表了
	
			}
			if(freeTable[i].status == free && freeTable[i].size > tmp.size){
				int orginalSize = freeTable[i].size;//暂时保留原来的分区大小
				freeTable[i].size = tmp.size;/*划分一区域为使用且把其标记为已使用*/
				freeTable[i].status = busy;//标记为使用了

				zone rest;/*分配给进程之后剩余内存*/
				rest. size = orginalSize - tmp.size; //剩余大小
				rest.start = freeTable[i].start + tmp.size;//剩余空闲分区起始地址
				rest.status = free;//设置为
				freeTable.push_back(rest);/*剩余空间加入分配表*/
				//cout<<"进程"<<tmp.id<<"内存分配成功,其大小是 "<<tmp.size<<endl;
				processQueue.pop();/*进程分配内存成功， 弹出进程队列*/
				tmp.start = freeTable[i].start;//设置进程运行的起始地址
				runVector.push_back(tmp);/*调入内存运行*/
				printf("进程%d内存分配成功,其在内存的起始地址是%d,大小是%d \n",
					tmp.id, tmp.start, tmp.size);
				break ;
				//return i; 
			}

		}

		if(i == length){//无足够大小的空闲区分配给进程
			cout<<"当前无法分配足够的内存给进程"<<tmp.id;
			cout<<"  等待某个进程释放"<<endl;
			/*开始释放进程*/
			releaseProcess();
			/*释放进程之后整理分配表，使其地址从小到大排序,为了合并内存*/
			//sort(freeTable.begin(), freeTable.end(), cmpByAddress);
			/*然后合并内存*/
			if(mergeMemory()){
				cout<<"有相邻内存合并成功"<<endl;
			}
			

		}

		cout<<"当前内存使用状况如下： "<<endl;
		showMemory();
		cout<<"---------------------------------------"<<endl;
	    /*if(i >= length)
			return 0; 
		else 
			return i; */
		return notEnd; /*表示此次有进程调入内存成功，进程队列不是空的*/

	}
	
	return End; /*表示全部的进程已成功分配内存*/
}


void reset(){/*重置相关数据结构*/
	runVector.clear();/*清空在运行中的进程向量*/
	runVector.shrink_to_fit();/*释放向量的内存*/

	freeTable.clear();/*清空分配表*/
	freeTable.shrink_to_fit();/*释放分配表的内存*/

	queue<process>empty;
	swap(empty, processQueue);/*清空进程队列*/

}

void Firstfit(){/*最先适应算法*/

	initProcess();
	initMemory();
	cout<<"当前内存使用状况如下： "<<endl;
	showMemory();
	/*开始分配内存*/
	int flag = 1;
	while(flag != End){/*如果还有进程没调入内存*/
		//先按起始地址从小到大排序，然后分配内存
		sort(freeTable.begin(), freeTable.end(), cmpByAddress);
		flag = allocateMemory();
	}


}



void Bestfit(){/*最佳适应算法*/
	
	initProcess();
	initMemory();

	cout<<"当前内存使用状况如下： "<<endl;
	showMemory();
	/*开始分配内存*/
	int flag = 1;
	while(flag != End){//进程队列还有进程，即还有进程没有调入内存
		/*排序使得空闲区的小区在前，大区在后*/
		sort(freeTable.begin(), freeTable.end(), cmpBySmallSize);
		flag = allocateMemory();
	}

}


void Nextfit(){/*循环适应算法*/

	initProcess();
	initMemory();

	cout<<"当前内存使用状况如下： "<<endl;
	showMemory();
	/*开始分配内存*/
	int last = -1;
	process tmp; 
	while(processQueue.size() != 0){
		bool flag = false; //标记这一趟是否成功分配内存给进程
		int length = freeTable.size();//分配表大小
		tmp = processQueue.front();//获取一个进程
		int i ; 
	
		for( i = (last + 1)%freeTable.size() ; (i % freeTable.size() ) != last; i = (i + 1) % freeTable.size()){
			
			if(freeTable[i].size < tmp.size)//分区太小
				continue; 
			//分区是空闲的且刚好足够容纳进程
			if(freeTable[i].status == free && freeTable[i].size == tmp.size){
				flag = true; 
				cout<<"进程"<<tmp.id<<" 内存分配成功,其大小是 "<<tmp.size<<endl;
				processQueue.pop();/*进程分配内存成功， 弹出进程队列*/
				freeTable[i].status = busy;//修改分区状态
				tmp.start = freeTable[i].start;//设置进程在内存的起始地址
				runVector.push_back(tmp);/*调入内存*/
				

				printf("进程%d内存分配成功,其在内存的起始地址是%d,大小是%d \n",
					tmp.id, tmp.start, tmp.size);
				break; //分配成功，不用继续查找分配表了
	
			}
			if(freeTable[i].status == free && freeTable[i].size > tmp.size){
				flag = true; 
				int orginalSize = freeTable[i].size;//暂时保留原来的分区大小
				freeTable[i].size = tmp.size;/*划分一区域为使用且把其标记为已使用*/
				freeTable[i].status = busy;//标记为使用了

				zone rest;/*分配给进程之后剩余内存*/
				rest. size = orginalSize - tmp.size; //剩余大小
				rest.start = freeTable[i].start + tmp.size;//剩余空闲分区起始地址
				rest.status = free;//设置为
				freeTable.push_back(rest);/*剩余空间加入分配表*/
				//cout<<"进程"<<tmp.id<<"内存分配成功,其大小是 "<<tmp.size<<endl;
				processQueue.pop();/*进程分配内存成功， 弹出进程队列*/
				tmp.start = freeTable[i].start;//设置进程运行的起始地址
				runVector.push_back(tmp);/*调入内存运行*/
				
				printf("进程%d内存分配成功,其在内存的起始地址是%d,大小是%d \n",
				tmp.id, tmp.start, tmp.size);
				break ;
				
			}

		}

		if( i  == last){//无足够大小的空闲区分配给进程
			cout<<"当前无法分配足够的内存给进程"<<tmp.id;
			cout<<"  等待某个进程释放"<<endl;
			/*开始释放进程*/
			releaseProcess();
			/*释放进程之后整理分配表，使其地址从小到大排序,为了合并内存*/
			sort(freeTable.begin(), freeTable.end(), cmpByAddress);
			/*然后合并内存*/
			if(mergeMemory()){
				cout<<"有相邻内存合并成功"<<endl;
			}
			

		}
		
		if(flag )/*成功分配内存，更新上一次分配内存的位置*/
			last = i; 
		//cout<<"last: "<<last<<endl;
		cout<<"当前内存使用状况如下： "<<endl;
		showMemory();
		cout<<"---------------------------------------"<<endl;
		

	}


}

void Worstfit(){/*最坏适应算法*/
	

	initProcess();
	initMemory();

	cout<<"当前内存使用状况如下： "<<endl;
	showMemory();
	/*开始分配内存*/
	int flag = 1;
	while(flag != End){//进程队列还没分配完
		/*排序使得空闲区的大区在前*/
		sort(freeTable.begin(), freeTable.end(), cmpByBigSize);
		flag = allocateMemory();
	}

}




int main()
{

	mp[busy] = "busy";
	mp[free] = "free";

	cout<<"---------------------最先适应算法---------------------"<<endl;

	Firstfit();
	reset();

	cout<<"---------------------最佳适应算法----------------"<<endl;
	Bestfit();
	reset();

	cout<<"---------------------循环适应算法--------"<<endl;
	Nextfit();
	reset();
	
	cout<<"---------------------最坏适应算法--------"<<endl;
	Worstfit();

	system("pause");
		
}

 

测试数据：

最先适应算法测试数据 
进程个数及其具体信息（进程id ，大小，运行时间 ）
5
1 10 3 
2 5 3
3 15 9 
4 10 3 

5 5 7 

内存起始地址和大小
0 40 
最佳适应算法测试数据

进程个数及其具体信息（进程id ，大小，运行时间 ）
5
1 10 3 
2 10  3
3 15 7
4 5 3 

5 5 7 

内存起始地址和大小
0 40
循环适应算法测试数据
进程个数及其具体信息（进程id ，大小，运行时间 ）
6
1 10 5 
2 10 2 
3 10 2 
4 10 5 
5 20 10 
6 10 7 

内存的起始地址和大小
0 40 
最坏适应算法测试数据
进程个数及其具体信息（进程id ，大小，运行时间 ）
5
1 10 3 
2 5 9 
3 15 3 
4 15 3 

5 10 1 

内存起始地址和大小
0 45

 

qq_lzq
关注
专栏目录
操作系统课程设计之存储管理—动态分区分配算法的模拟
07-09
课题八:存储管理---动态分区分配算法的模拟： 要求设计主界面以灵活选择某算法，且以下算法都要实现：首次适应算法、循环首次适应算法、最佳适应算法；
存储管理——动态分区分配算法的模拟
09-14
存储管理——动态分区分配算法的模拟 要求设计主界面以灵活选择某算法，以下算法都要实现： a、首次适应算法 b、循环首次适应算法 c、最佳适应算法 d、最坏适应算法 e、快速适应算法 具体要求： 1）首先由系统生成当前的内存状态，要求未分配的分区数量不少于3个，且空间大小随机，然后随机生成一个数，表示等待分配进程的大小; 2）然后显示上述算法由用户选择，结果显示分配后的状态; 添加要去： 1）在原要求基础上添加手动输入功能； 2）界面友好，操作方便。
实验四 动态多分区存储管理模拟
最新发布
m0_74321088的博客
07-07 757
1．对理论课中学习的内存管理当中的概念做进一步的理解；2. 明白内存管理的主要任务；3．了解内存管理任务的主要实现方法；4．掌握内存的分配,回收等主要算法的原理；5. 通过编程,熟悉分区式存储管理方法中内存分配回收算法的实现方式。
OS课程设计_动态分区分配算法
07-27
操作系统的动态分区分配算法（控制台程序），供学习使用。
动态分区分配存储管理-操作系统课程设计
07-04
动态分区分配存储管理。（3人） 4分 建立描述内存分配状况的数据结构； 建立描述进程的数据结构； 使用两种方式产生进程：（a）自动产生， （b）手工输入； 在屏幕上显示内存的分配状况、每个进程的执行情况； 建立分区的分配与回收算法，支持紧凑算法； 时间的流逝可用下面几种方法模拟：（a）按键盘，每按一次可认为过一个时间单位； (b) 响应WM_TIMER； 将一批进程的执行情况存入磁盘文件，以后可以读出并重放； 支持算法：首次适应算法、循环首次适应算法、最佳适应算法：最坏适应算法。
存储管理---动态分区分配算法的模拟
03-22
自己做的综合实践,有参照课本. 用c++写的,含源代码,含报告,且程序运行通过.
课程设计：存储管理——动态分区分配算法的模拟.doc
05-30
存储管理中的动态分区分配算法模拟 在计算机科学中，存储管理是操作系统中一个非常重要的组成部分。存储管理的主要作用是管理计算机中的存储资源，使得存储资源能够被高效地利用。其中，动态分区分配算法是存储管理...
操作系统课程设计--连续动态分区内存管理模拟实现.doc
05-06
### 操作系统课程设计——连续动态分区内存管理模拟实现 #### 一、引言 在计算机科学领域，操作系统作为连接硬件与应用软件的重要桥梁，其核心任务之一就是有效地管理和调度计算机系统的资源，特别是内存资源。...
合肥工业大学操作系统课程设计 动态分区分配存储管理java版.doc
06-11
【合肥工业大学操作系统课程设计——动态分区分配存储管理Java版】是一项针对操作系统理论的实践项目，旨在让学生深入理解动态分区分配的存储管理机制。这个设计涵盖了以下几个核心知识点： 1. **动态分区分配**：...
内存分配_课程设计：可变分区存储管理算法模拟.docx
05-29
### 内存分配_课程设计：可变分区存储管理算法模拟 #### 一、课程设计目的及背景 本次课程设计的主要目标是通过编程的方式模拟可变分区存储管理系统的内存分配与回收过程。可变分区存储管理是操作系统内存管理中一...
磁盘空间管理的模拟与实现（操作系统课程设计）
比物理简单的博客
12-24 2189
粉丝可见，关注即可获取源码 本程序使用c/c++实现了操作系统课程设计《磁盘空间管理的模拟》题目 使用了位示图法（位图）实现功能 代码已实现在vc++6.0中成功运行 此题目说明书，任务书，课程设计所有内容部分已打包放在个人资源下载里，点击主页自取 代码如下： #include<stdio.h> #include<windows.h> unsigned int size[5]={0,0,0,0,0};//保存位示图 void out()//输出位示图函数 { p
操作系统课程设计动态分区分配存储管理.doc
12-29
操作系统课程设计动态分区分配存储管理
动态分区分配算法
06-22
《计算机与操作系统（第四版）》动态分区分配算法 1.首次适应算法（first fit） 2.循环首次适应算法（next fit） 3.最佳适应算法（best fit）
操作系统课程设计-动态分区分配存储管理-报告+VS2019源码工程-C
01-23
● 建立描述内存分配状况的数据结构； ● 建立描述进程的数据结构； ● 使用两种方式产生进程：（a）自动产生， （b）手工输入； ● 在屏幕上显示内存的分配状况、每个进程的执行情况； ● 建立分区的分配与回收算法，支持紧凑算法； ● 时间的流逝可用下面几种方法模拟： (a) 按键盘，每按一次可认为过一个时间单位； (b) 响应WM_TIMER； ● 将一批进程的执行情况存入磁盘文件，以后可以读出并重放； ● 支持算法： 首次适应算法、循环首次适应算法、最佳适应算法、最坏适应算法。 压缩包里有内核工程和演示工程，内核C语言，演示c++（内核已生成lib），有成品报告
动态分区分配算法实现（代码+文档）
06-29
⑴首次适应算法实现 从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法目的在于减少查找时间。为适应这种算法，空闲分区表（空闲区链）中的空闲分区要按地址由低到高进行排序。该算法优先使用低址部分空闲区，在低址空间造成许多小的空闲区，在高地址空间保留大的空闲区。 ⑵循环首次适应算法实现 该算法是首次适应算法的变种。在分配内存空间时，不再每次从表头（链首）开始查找，而是从上次找到空闲区的下一个空闲开始查找，直到找到第一个能满足要求的的空闲区为止，并从中划出一块与请求大小相等的内存空间分配给作业。该算法能使内存中的空闲区分布得较均匀。 ⑶最佳适应算法实现 它从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区，这种方法能使碎片尽量小。为适应此算法，空闲分区表（空闲区链）中的空闲分区要按从小到大进行排序，自表头开始查找到第一个满足要求的自由分区分配。 ⑷最坏算法实现 最坏适应分配算法要扫描整个空闲分区或链表，总是挑选一个最大的空闲分区分割给作业使用。该算法要求将所有的空闲分区按其容量从大到小的顺序形成一空闲分区链，查找时只要看第一个分区能否满足作业要求。
存储管理——动态分区分配算法
06-23
操作系统课设做的动态分区分配算法。第一次上传资源，做的有些乱，献丑了，其中循环首次循环和最佳、最坏分配算法其实只是从首次适应算法改了一点东西。 补充几句，是JAVA做的，分配和回收算法都有，使用数组实现
java动态分区分配_操作系统 动态分区分配算法课程设计 java版.pdf
weixin_32280985的博客
02-21 434
操作系统 动态分区分配算法课程设计 java版湖 南 文 理 学 院 实 验 报 告课程名称 操作系统课程设计实验名称 存储管理——动态分区分配算法的模拟成绩学生姓名 曹乐 专业 计算机班级、学号 13101 18同组者姓名实验日期 12...
java动态分区分配_操作系统动态分区分配算法课程设计java版解析.doc
weixin_35851654的博客
02-25 377
湖 南 文 理 学 院 实 验 报 告课程名称 操作系统课程设计实验名称 存储管理——动态分区分配算法的模拟成绩学生姓名 曹乐 专业 计算机班级、学号 13101 18同组者姓名实验日期 12.21实验目的通过这次实验，加深对动态分区分配算法的理解，进一步掌握首次适应算法、循环首次适应算法、最佳适应算法、最坏适...
java动态分区分配_操作系统_动态分区分配算法课程设计_java版
weixin_34342091的博客
02-21 262
湖南文理学院实验报告课程名称操作系统课程设计实验名称存储管理——动态分区分配算法的模拟成绩学生姓名曹乐专业计算机班级、学号 13101 18同组者姓名实验日期 12.211、实验目的通过这次实验，加深对动态分区分配算法的理解，进一步掌握首次适应算法、循环首次适应算法、最佳适应算法、最坏适应算法和快速适应算法的实现方法。2、试验内容问题描述：设计程序模拟四种动态分区分配算法：首次适应算法、循环首次适...
操作系统课程设计：动态分区存储管理模拟
"操作系统课程设计，主要内容是模拟动态分区存储管理的分配与回收，涉及到最优适应和最先适应算法。设计任务包括实现内存分配、回收功能，处理不同回收情况，并撰写设计报告，涵盖目的、功能、需求分析、源代码、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值