动态分区算法

最新推荐文章于 2024-05-11 23:45:19 发布
最新推荐文章于 2024-05-11 23:45:19 发布
阅读量601 收藏 15
点赞数 21
分类专栏： java，c，数据结构等相关作业 文章标签： java jvm 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62075168/article/details/137546303
版权

一个不知名大学生，江湖人称菜狗
original author: Jacky Li
Email : 3435673055@qq.com

Time of completion：2024.04.09
Last edited: 2024.04.09

目录

动态分区算法

第1关：首次适应算法

任务描述

相关知识

内存分配

内存回收

编程要求

测试说明

代码如下

第2关：最佳适应算法

相关知识

内存分配

内存回收

编程要求

测试说明

代码如下

动态分区算法

第1关：首次适应算法

任务描述

假设初始状态下可用的内存空间为55MB，并有如下的请求序列： 作业1申请15MB 作业2申请30MB 作业1释放15MB 作业3分配8MB 作业4分配6MB 作业2释放30MB 请采用首次适应算法进行内存块的分配和回收，并打印出空闲内存分区链的情况

相关知识

为了完成本关任务，你需要掌握使用首次适应算法进行内存块的分配与回收。

内存分配

空闲分区链按地址递增的顺序链接。在分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区。然后再按照作业的大小，从该分区中划出一块内存空间，分配给请求者，余下的空闲分区仍留在空闲链中。若从链首到链尾都找不到一个能满足要求的分区，则表明系统没有足够大的内存分配给该进程，内存分配失败返回。

内存回收

当进程运行完毕释放内存时，系统根据回收区的首址，从空闲区链(表)中找到相应的插入点，此时可能出现以下四种情况之一： (1) 回收区与插入点的前一个空闲分区F1相邻接，此时应将回收区与插入点的前一分区合并，不必为回收分区分配新表项，而只需修改其前一分区F1的大小。 (2) 回收分区与插入点的后一空闲分区F2相邻接，此时也可将两分区合并，形成新的空闲分区，但用回收区的首址作为新空闲区的首址，大小为两者之和。 (3) 回收区同时与插入点的前、后两个分区F1和F2邻接，此时将三个分区合并，使用F1的表项和F1的首址，取消F2的表项，大小为三者之和。 (4) 回收区前后没有空闲分区。这时应为回收区单独建立一个新表项，填写回收区的首址和大小，并根据其首址插入到空闲链中的适当位置

编程要求

空闲分区采用带头结点的双向链表来管理，主函数、链表初始化函数和打印函数已实现，只需要补充首次适应算法分配内存的函数 first_fit以及内存回收的函数recycle()即可。

bool first_fit(int id,int m_size)//使用首次适应算法给作业分配内存，id为作业号，m_size为作业大小 void recycle(int id)//回收内存,id为释放内存的作业号

测试说明

平台会对你编写的代码进行测试：

代码如下

#include <stdio.h>
#include <stdlib.h>

const int Max_length=55;//最大内存

struct areaNode//管理分区的结构体
{	
    int ID;//分区号	
    int size;//分区大小	
    int address;//分区地址	
    int flag;//使用状态，0为未占用，1为已占用
};

typedef struct DuNode//双向链表结点
{ 
  struct areaNode data;//数据域	
  struct DuNode *prior;//指针域	
  struct DuNode *next;
}*DuLinkList;
DuLinkList m_head = new DuNode, m_last = new DuNode;//双向链表首尾指针
  
void init()//分区链表初始化
{	
  m_head->prior = NULL;	
  m_head->next = m_last;	
  m_last->prior = m_head;	
  m_last->next = NULL;	
  m_head->data.size = 0;	
  m_last->data.address = 0;	
  m_last->data.size = Max_length;	
  m_last->data.ID = 0;
  m_last->data.flag = 0;
}

void show()
{	
  DuNode *p = m_head->next;//指向空闲区队列的首地址	
  printf("+++++++++++++++++++++++++++++++++++++++\n");	
  while (p)	
  {		
    printf("分区号：");		
	if (p->data.ID == 0)			
	  printf("FREE\n");		
	else			
	  printf("%d\n",p->data.ID);		
	printf("分区起始地址：%d\n",p->data.address);		
	printf("分区大小：%d\n",p->data.size);		
	printf("分区状态：");		
	if (p->data.flag)			
	  printf("已被占用\n");		
	else			
	  printf("空闲\n");		
	printf("——————————————————\n");		
	p = p->next;	
  }
} 

bool first_fit(int id,int m_size)//首次适应算法,id为作业号，m_size为作业大小 
{    
    //请补充使用首次适应算法给作业分配内存的函数代码
    DuLinkList temp=(DuLinkList)malloc(sizeof(DuNode));//申请双向链表指针节点temp(*a.b=a->b) 
    DuNode *p=m_head->next;
    temp->data.ID=id;//*temp.data.ID
    temp->data.size=m_size;
    temp->data.flag=1;
    
    while(p){//循环查找 
      
        if(p->data.flag==0&&p->data.size==m_size){//p节点未占用，并且空间刚好满足 
            p->data.flag=1;
            p->data.ID=id;
           return false;
        }
        if(p->data.flag==0&&p->data.size>m_size){//p节点未占用，且空间大于所需 
            temp->next=p;
            temp->prior=p->prior;//temp 插入p之前 
            
            temp->data.address=p->data.address;//分区起始地址 
            p->prior->next=temp;
            p->prior=temp;
            p->data.address=temp->data.address+temp->data.size;
            p->data.size-=m_size;
          return false;
        }
        p=p->next;
    }
  return true;

}


void recycle(int id)//回收内存,id为释放内存的作业号 
{    
    //请补充回收作业内存的代码
    
     DuLinkList n=m_head->next ;
    while(n)
    {
       
        DuLinkList q=n->next;
        if(n->data.ID==id)
        {
            if(n->prior!=m_head&&n->prior->data.flag==0&&n->next->data.flag==0)
            {
                n->prior->data.size = n->prior->data.size+q->data.size+n->data.size;
                 q->prior= n->prior;
                 n->prior->next=q;
                 
                 if(q==m_last)
                 {
                 n->prior->next=NULL;
                 n->prior->data.ID=0;
                 }
                 delete(n);
                
            }
            else if(n->prior!=m_head&&n->prior->data.flag==0&&n->next->data.flag != 0)
            { 
                n->prior->data.size+=n->data.size;
                n->prior->next=q;
                q->prior=n->prior;
                delete n;
                break; 
            }
            else if(n->next->data.flag==0&&n->prior->data.flag!=0&&n->prior!=m_head)
            { 
              n->data.size+=q->data.size;
              n->next=q->next;
              n->data.flag=0;
              q->next->prior=n;
              delete q;
              break;
            }
            else
            {
              n->data.flag=0;
              
              break;
            }
        }
        n=n->next;
    }
    
}
int main()
{
	init();
        
    printf("首次适应算法：\n");
	first_fit(1,15);
	first_fit(2,30);
	recycle(1);
	first_fit(3,8);
	first_fit(4,6);
	recycle(2);
	
	show();
	
	DuNode *p = m_head;
	while(p != NULL)
	{
		DuNode *temp =  p;
		p = p->next;
		delete(temp);
		temp = NULL;
	}
	
	return 0;
}

第2关：最佳适应算法

假设初始状态下可用的内存空间为55MB，并有如下的请求序列： 作业1申请15MB 作业2申请30MB 作业1释放15MB 作业3分配8MB 作业4分配6MB 作业2释放30MB 请采用最佳适应算法进行内存块的分配和回收，并打印出空闲内存分区链的情况

相关知识

为了完成本关任务，你需要掌握使用最佳适应算法进行内存块的分配与回收。

内存分配

每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业，避免“大材小用”。若从链首到链尾都找不到一个能满足要求的分区，则表明系统没有足够大的内存分配给该进程，内存分配失败返回。

内存回收

当进程运行完毕释放内存时，系统根据回收区的首址，从空闲区链(表)中找到相应的插入点，此时可能出现以下四种情况之一： (1) 回收区与插入点的前一个空闲分区F1相邻接，此时应将回收区与插入点的前一分区合并，不必为回收分区分配新表项，而只需修改其前一分区F1的大小。 (2) 回收分区与插入点的后一空闲分区F2相邻接，此时也可将两分区合并，形成新的空闲分区，但用回收区的首址作为新空闲区的首址，大小为两者之和。 (3) 回收区同时与插入点的前、后两个分区F1和F2邻接，此时将三个分区合并，使用F1的表项和F1的首址，取消F2的表项，大小为三者之和。 (4) 回收区前后没有空闲分区。这时应为回收区单独建立一个新表项，填写回收区的首址和大小，并根据其首址插入到空闲链中的适当位置

编程要求

空闲分区采用带头结点的双向链表来管理，主函数、链表初始化函数和打印函数已实现，只需要补充最佳适应算法分配内存的函数 best_fit以及内存回收的函数recycle()即可。

bool best_fit(int id,int m_size)//使用最佳适应算法给作业分配内存，id为作业号，m_size为作业大小 void recycle(int id)//回收内存,id为释放内存的作业号

测试说明

平台会对你编写的代码进行测试：

代码如下

#include <stdio.h>
#include <stdlib.h>

const int Max_length=55;//最大内存

struct areaNode//管理分区的结构体
{	
    int ID;//分区号	
    int size;//分区大小	
    int address;//分区地址	
    int flag;//使用状态，0为未占用，1为已占用
};

typedef struct DuNode//双向链表结点
{ 
  struct areaNode data;//数据域	
  struct DuNode *prior;//指针域	
  struct DuNode *next;
}*DuLinkList;
DuLinkList m_head = new DuNode, m_last = new DuNode;//双向链表首尾指针
  
void init()//分区链表初始化
{	
  m_head->prior = NULL;	
  m_head->next = m_last;	
  m_last->prior = m_head;	
  m_last->next = NULL;	
  m_head->data.size = 0;	
  m_last->data.address = 0;	
  m_last->data.size = Max_length;	
  m_last->data.ID = 0;
  m_last->data.flag = 0;
}

void show()
{	
  DuNode *p = m_head->next;//指向空闲区队列的首地址	
  printf("+++++++++++++++++++++++++++++++++++++++\n");	
  while (p)	
  {		
    printf("分区号：");		
	if (p->data.ID == 0)			
	  printf("FREE\n");		
	else			
	  printf("%d\n",p->data.ID);		
	printf("分区起始地址：%d\n",p->data.address);		
	printf("分区大小：%d\n",p->data.size);		
	printf("分区状态：");		
	if (p->data.flag)			
	  printf("已被占用\n");		
	else			
	  printf("空闲\n");		
	printf("——————————————————\n");		
	p = p->next;	
  }
} 


bool best_fit(int id, int m_size)//最佳适应算法，其中需要查找最佳的存放位置
{	
    //请补充使用最佳适应算法给作业分配内存的函数代码
    
    DuLinkList m = new DuNode;
	DuNode *p = m_head->next; 
	DuNode *q;
	int min=1000;
	while(p)
	{
		
		if(p->data.flag==0) 
		{
			int size=p->data.size-m_size;
			if(size<min&&size>0) 
			{
				q=p;
				min = size;
			}
		}
		p=p->next;
	 }
	m->prior= q->prior;
	q->prior->next=m;
	m->next=q;
	q->prior =m;
	
	m->data.flag=1;
	if(m->prior==m_head)
	m->data.address= 0;
	else
	m->data.address=m->prior->data.address+m->prior->data.size;
	
	m->data.ID=id;
	m->data.size=m_size;
	
	q->data.address=m->data.address+m->data.size;
	q->data.ID=0;
	q->data.size = q->data.size-m_size; 
	
	 
	
}
	



void recycle(int id)//回收内存,id为释放内存的作业号 
{	
    //请补充回收作业内存的函数代码
     DuLinkList n=m_head->next ;
    while(n)
    {
       
        DuLinkList q=n->next;
        if(n->data.ID==id)
        {
            if(n->prior!=m_head&&n->prior->data.flag==0&&n->next->data.flag==0)
            {
                n->prior->data.size = n->prior->data.size+q->data.size+n->data.size;
                 q->prior= n->prior;
                 n->prior->next=q;
                 
                 if(q==m_last)
                 {
                 n->prior->next=NULL;
                 n->prior->data.ID=0;
                 }
                 delete(n);
                
            }
            else if(n->prior!=m_head&&n->prior->data.flag==0&&n->next->data.flag != 0)
            { 
                n->prior->data.size+=n->data.size;
                n->prior->next=q;
                q->prior=n->prior;
                delete n;
                break; 
            }
            else if(n->next->data.flag==0&&n->prior->data.flag!=0&&n->prior!=m_head)
            {
              n->data.size+=q->data.size;
              n->next=q->next;
              n->data.flag=0;
              q->next->prior=n;
              delete q;
              break;
            }
            else
            {
              n->data.flag=0;
              
              break;
            }
        }
        n=n->next;
    }
    
}

int main()
{
	init();
	 
    //最佳适应算法
	printf("最佳适应算法：\n");
	init();
	best_fit(1,15);
	best_fit(2,30);
	recycle(1);
	best_fit(3,8);
	best_fit(4,6);
	recycle(2); 
	

	show();
	
	DuNode *p = m_head;
	while(p != NULL)
	{
		DuNode *temp =  p;
		p = p->next;
		delete(temp);
		temp = NULL;
	}
	
	return 0;
}

羁旅少年
关注
  • 21
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
存储管理：最佳适应算法代码解析
星辰大海的博客
07-21 856
算法流程图： 逐段解析代码： 头文件和自定义数据结构 #include<stdio.h> #include <dos.h> #include<stdlib.h> #include <conio.h> #define n 10 //假定系统允许的最大作业数为n，假定模拟实验中n值为10 #define m 10 //假定系统允许的空闲区表最大为m，假定模拟实验中m值为10 #define minisize 100 /*空闲分区被分配时， .
内存管理-最先适应算法和最佳适应算法-模拟程序
05-10
设计了一个内存管理模拟程序，实现了最先适应算法和最佳适应算法，可以手动申请内存大小，释放内存，同时附有测试程序，可设置测试次数，同时统计了平均申请内存大小，内存利用率及运行时间。
内存分配---FF、BF、WF三种算法
weixin_30878501的博客
05-20 3827
动态分区分配是根据进程的实际需要，动态的为之分配内存空间。而在实现可变分区分配时，将涉及到分区分配中 所用的数据结构、分区分配算法和分区的分配与内存回收的过程。 分区分配中的数据结构：（1）描述空闲块的数据结构。（2）内存块的描述。 #define PROCESS_NAME_LEN 32 //进程名长度 #define MIN_SLICE 10 ...
操作系统--03内存管理
weixin_45229936的博客
09-16 1138
3.1.4 连续分配管理方式—实现内存空间的分配和回收，功能一 连续分配：指为用户进程分配的必须是一个连续的内存空间 单一连续分配： 设计思想：内存被分为系统区和用户区。系统区通常位于内存的低地址部分，用户存放操作系统的相关数据；用户区存放用户进程相关数据。内存中同一时刻只能有一道用户程序，用户程序独占整个用户区。 优点：实现简单，无外部碎片。可以采用覆盖技术扩充内存，不一定需要采取内存保护。 缺点：只支持单用户、单任务的操作系统。会产生内部碎片，内部碎片指的没有用上的内存空间。存储器利用率低。 固定分区分
存储管理之分配算法
Chen_dSir的博客
10-25 3310
操作系统之存储管理 分配算法: 1.最佳适应法 最佳适应算法要求空闲区按大小递增的次序排列.在进行内存分配时,从空闲分区表首开始顺序查找,直到找到第一个能满足其大小要求的空闲区为止,如果该空闲区大于请求表中的请求长度,则将剩余空闲区留在可用表中(如果相邻有空闲区,则与之和并),然后修改相关表的表项.按这种方式为作业分配内存,就能把既满足要求又与作业大小接近的空闲分区分配给作业.如果空闲区大
基于顺序搜索的动态分区算法
noname 博客
10-11 2010
首次适应算法（first fit ，ff） 要求 空闲链递增的方式链接 工作方式 从链首开始查找，直到找到一个大小能满足要求的空闲分区为止 特点 优先利用内存中低地址部分 高地址空闲区大，可以给大程序使用 低地址不断被分割，形成碎片 每次从低地址查找，开销大 循环首次适应算法（next fit，nf） 解决问题 为了解决 ff 算法的缺点 特点 从上一次找到的空闲分区的下一个空闲分区开始查找...
内存动态分区算法.doc
07-04
xx大学计算机学院操作系统的课程设计报告之内存的动态分区算法
操作系统——实验五 动态分区分配算法的模拟
08-05
用C/C++实现一个完整的（可变）动态分区管理器，包括分配，回收，分区碎片整理等。希望同学们实现如下功能： 初始化功能：内存状态设置为初始状态。 分配功能：要求至少使用两种算法，用户可以选择使用。 回收...
操作系统动态分区算法.txt
05-26
操作系统动态分区算法.txt
动态分区分配算法
01-11
动态分区分配算法，里面包括首次适应算法，最佳适应算法哟，大家可以下载来看看呢
第三章 内存管理 五、动态分区分配算法（首次适应算法、最佳适应算法、最坏适应算法、临近适应算法）
icbbm的博客
10-16 967
每次都选最大的分区进行分配，虽然可以让分配后留下的空闲区更大，更可用，但是这种方式会导致较大的连续空闲区被迅速用完。算法思想:为了解决最佳适应算法的问题――即留下太多难以利用的小碎片，可以在每次分配时优先使用最大的连续空闲区，这样分配后剩余的空闲区就不会太小，更方便使用。（1）假设我们要插入一个大小为15MB的内存，它会比较空闲区的大小，第一次遇到的空闲区为20MB，所以直接放入。每次分配内存时从上次查找结束的位置开始查找空闲分区链（或空闲分区表)，找到大小能满足要求的第一个空闲分区。
动态分区算法（头歌实验）第1关：首次适应算法。第2关：最佳适应算法。
m0_65420451的博客
11-18 4643
动态分区算法（头歌实验）第1关：首次适应算法。第2关：最佳适应算法。假设初始状态下可用的内存空间为55MB，并有如下的请求序列： 作业1申请15MB 作业2申请30MB 作业1释放15MB 作业3分配8MB 作业4分配6MB 作业2释放30MB 请采用首次适应算法进行内存块的分配和回收，并打印出空闲内存分区链的情况。
存储管理原理最先适应--操作系统专题作业
hzy626372333的博客
01-14 2710
一、问题描述 设物理内存320KB，共有10个进程先后申请进入内存，进程详细情况见表1-1。 其中实现动态分区管理的具体要求如下： 1. 设计动态分区存储管理必须的表格，例如分区说明表、可用表或自由链； 2. 内存分配策略包括最先适应、最佳适应、最坏适应三种，程序可实现不同内存策略的切换； 3. 程序能够实现“当一个进程申请使用内存时，能够显示该进程在内存的占用情况及其可用表和分区说明表的变化情况；当一个进程执行完毕释放内存时，能够显示可用表和分区说明表的变化情况”; 表1-1 进程相关信息
操作系统-内存管理-最佳适应算法
qq_43149127的博客
12-01 1032
#include <iostream> #include <cstdio> #include <cstdlib> #include <cstring> #include <time.h> using namespace std; struct node{ //status表示当前节点的状态 0:空闲 1:占用 //free_space表示当前节点的空余空间 //*str表示当前存储字符串的首地址 //index表示当
java jar包如何运行或调用
NLP与推荐算法
05-08 382
java服务启动
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 432
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
【全面介绍下Spring】
最新发布
2301_81357485的博客
05-11 597
Spring框架提供了用于构建Web应用程序的多个模块，如Spring MVC、Spring WebFlux和Spring Web Services。Spring使用IoC容器来管理应用组件之间的依赖关系，通过IoC，开发人员可以将对象的创建和组装转移给Spring容器来管理，从而降低了组件之间的耦合。🌈总之，Spring框架为Java应用程序开发提供了丰富的功能和强大的扩展性，它通过提供模块化的解决方案和简化开发流程，帮助开发人员更高效地构建高质量的企业级应用程序。
动态分区算法实验
05-24
动态分区算法是内存管理中常用的一种算法，它的主要思想是根据进程的需要动态地分配内存，以满足进程的需求。下面是一个简单的动态分区算法实验。 实验环境： - 操作系统：Windows/Linux - 编程语言：C/C++ 实验步骤： 1. 初始化内存空间 首先，我们需要初始化一段内存空间，这个空间可以看作是操作系统为进程分配的内存空间。我们可以使用一个结构体来表示这段内存空间，该结构体包含了内存块的大小和状态信息。 ```c++ struct MemoryBlock { int size; // 内存块大小 bool is_free; // 内存块是否空闲 }; ``` 然后，我们可以创建一个数组来表示内存空间中的多个内存块，如下所示： ```c++ MemoryBlock memory[10]; ``` 在初始化时，我们需要将这些内存块的状态都设为“空闲”。 ```c++ for (int i = 0; i < 10; i++) { memory[i].size = 0; memory[i].is_free = true; } ``` 2. 实现动态分区分配算法 在动态分区分配算法中，我们需要实现两个主要函数：分配函数和释放函数。 分配函数的作用是根据进程需要的内存大小，从内存空间中找到一个足够大的内存块，并将其分配给进程使用。如果找不到足够大的内存块，则分配失败。 ```c++ void* allocate_memory(int size) { for (int i = 0; i < 10; i++) { if (memory[i].is_free && memory[i].size >= size) { // 找到一个足够大的空闲内存块 memory[i].is_free = false; return &memory[i]; } } // 没有找到足够大的空闲内存块 return nullptr; } ``` 释放函数的作用是将进程占用的内存块标记为“空闲”，以便其他进程可以使用该内存块。 ```c++ void free_memory(void* ptr) { MemoryBlock* block = (MemoryBlock*)ptr; block->is_free = true; } ``` 3. 测试动态分区分配算法 我们可以编写一个简单的程序来测试我们实现的动态分区分配算法。该程序首先初始化内存空间，然后分配、释放若干内存块，并输出每个内存块的状态信息。 ```c++ int main() { // 初始化内存空间 for (int i = 0; i < 10; i++) { memory[i].size = rand() % 100 + 1; // 随机生成内存块大小 memory[i].is_free = true; } // 分配、释放若干内存块 void* p1 = allocate_memory(20); void* p2 = allocate_memory(50); free_memory(p1); void* p3 = allocate_memory(30); void* p4 = allocate_memory(80); free_memory(p2); free_memory(p3); void* p5 = allocate_memory(70); // 输出每个内存块的状态信息 for (int i = 0; i < 10; i++) { printf("Memory block %d: size=%d, is_free=%d\n", i, memory[i].size, memory[i].is_free); } return 0; } ``` 运行程序后，输出结果如下： ``` Memory block 0: size=31, is_free=0 Memory block 1: size=69, is_free=1 Memory block 2: size=56, is_free=1 Memory block 3: size=42, is_free=1 Memory block 4: size=47, is_free=1 Memory block 5: size=40, is_free=1 Memory block 6: size=38, is_free=1 Memory block 7: size=25, is_free=0 Memory block 8: size=81, is_free=0 Memory block 9: size=9, is_free=1 ``` 可以看到，我们实现的动态分区分配算法可以正确地分配、释放内存块，并维护每个内存块的状态信息。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

羁旅少年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值