可变分区存储管理方案中的内存分配
操作系统第四 十章自测题及解答
1、将作业地址空间中的逻辑地址转换为主存中的物理地址的过程称为（ ）。
2、分区分配中的存储保护通常采用（ ）和（ ）方法。
3、重定位的方式有（ ）和（ ）两种。
4、静态重定位在（ ）时进行：而动态重定位在（ ）时进行。
5、在虚拟存储管理中，虚拟地址空间是指逻辑地址空间，实地址空间是指（ ）；前者的大小只受（ ）限制，而后者的大小受（ ）。
6、在段式虚拟存储管理中，程序所使用的最大段数以及段的最大长度是由（ ）来决定的。
7、在段页式存储管理系统中，每道程序都有一个（ ）表和一组（ ）表。
8、若选用的（ ）算法不合适，可能会出现抖动现象。
9、在页式存储管理系统中，常用的页面淘汰算法有：（ ），选择淘汰不再使用或最远的将来才使用的页；（ ），选择淘汰在主存驻留时间最长的页；（ ），选择淘汰离当前时刻最近的一段时间内使用得最少的页。
10、Linux能支持许多不同的文件系统原因是它实现了与许多其他的操作系统可以很好兼容的（）。
11、索引文件大体上由：( )区和( )构成。
其中索引)区一般按关键字的顺序存放。
12、数据传送方式有（ ）、（ ）和（ ）。
13、对操作系统而言，打开文件的主要作用是装入( )目录表。
14、从文件的逻辑结构上来说，可将文件分为( ) 文件和( )文件。
15、常用的文件物理结构有 （ ）、（ ）、（ ）等三种。
16、为了对文件系统中的文件进行安全管理，任何一个用户在进入系统时都必须进行注册，这一级安全管理是（ ）安全管理。
17、为了解决不同用户文件的“命名冲突”问题，通常在文件系统中采用（）。
18、文件的安全性是指抵抗和预防各种物理性破坏及人为性破坏的能力，保证文件安全性常用的措施是（）。
19、在一般操作系统中，设备管理的主要功能包括（）、（）、（）和（）。
20、（ ）是指能够控制一台或多台外围设备，独立完成输入输出操作的处理机。
21、虚拟设备是通过（）技术把（）设备变成能为若干用户（）的设备。
可变分区存储管理的内存分配算法模拟实现----最佳适应算法
可变分区存储管理的内存分配算法模拟实现----最佳适应算法可变分区存储管理是一种内存管理技术，其通过将内存分割成不同大小的区域来存储进程。
每个进程被分配到与其大小最匹配的区域中。
内存分配算法的选择影响了系统的性能和资源利用率。
本文将介绍最佳适应算法，并模拟实现该算法。
一、什么是最佳适应算法？最佳适应算法是一种可变分区存储管理中的内存分配策略。
它的基本思想是在每次内存分配时选择最合适的空闲区域。
具体来说，它从可用的空闲区域中选择大小与需要分配给进程的内存最接近的区域。
二、算法实现思路最佳适应算法实现的关键是如何快速找到最合适的空闲区域。
下面给出一个模拟实现的思路：1. 初始化内存分区列表，首先将整个内存定义为一个大的空闲区域。
2. 当一个进程请求分配内存时，从列表中找到与所需内存最接近的空闲区域。
3. 将该空闲区域分割成两部分，一部分分配给进程，并将该部分标记为已分配，另一部分留作新的空闲区域。
4. 更新内存分区列表。
5. 当一个进程释放内存时，将其所占用的内存区域标记为空闲，然后尝试合并相邻的空闲区域。
三、算法模拟实现下面是一个简单的Python代码实现最佳适应算法：pythonclass MemoryPartition:def __init__(self, start_addr, end_addr, is_allocated=False): self.start_addr = start_addrself.end_addr = end_addrself.is_allocated = is_allocatedclass MemoryManager:def __init__(self, total_memory):self.total_memory = total_memoryself.partition_list = [MemoryPartition(0, total_memory)]def allocate_memory(self, process_size):best_fit_partition = Nonesmallest_size = float('inf')# 找到最佳适应的空闲区域for partition in self.partition_list:if not partition.is_allocated and partition.end_addr - partition.start_addr >= process_size:if partition.end_addr - partition.start_addr < smallest_size:best_fit_partition = partitionsmallest_size = partition.end_addr - partition.start_addrif best_fit_partition:# 将空闲区域分割，并标记为已分配new_partition =MemoryPartition(best_fit_partition.start_addr,best_fit_partition.start_addr + process_size, True)best_fit_partition.start_addr += process_sizeself.partition_list.append(new_partition)return new_partition.start_addr,new_partition.end_addrelse:return -1, -1def deallocate_memory(self, start_addr, end_addr):for partition in self.partition_list:if partition.start_addr == end_addr and not partition.is_allocated:# 标记空闲区域partition.is_allocated = False# 尝试合并相邻空闲区域for next_partition in self.partition_list:if not next_partition.is_allocated andnext_partition.start_addr == end_addr:end_addr = next_partition.end_addrself.partition_list.remove(next_partition)breakelse:breakdef print_partitions(self):for partition in self.partition_list:if partition.is_allocated:print(f"Allocated Partition: {partition.start_addr} - {partition.end_addr}")else:print(f"Free Partition: {partition.start_addr} - {partition.end_addr}")# 测试最佳适应算法if __name__ == "__main__":mm = MemoryManager(1024)start, end = mm.allocate_memory(256)print(f"Allocated memory: {start} - {end}")mm.print_partitions()mm.deallocate_memory(start, end)print("Memory deallocated:")mm.print_partitions()以上代码实现了一个简单的内存管理器类`MemoryManager`，它具有`allocate_memory`和`deallocate_memory`等方法。
操作系统中内存管理的重要性和实现方法
操作系统中内存管理的重要性和实现方法操作系统中内存管理是系统内核的核心功能之一，它负责管理计算机的内存资源，以提供可靠、高效的运行环境。
内存管理的目标是合理分配和管理内存空间，同时确保进程之间的隔离和保护，提高系统的性能和可靠性。
本文将介绍操作系统中内存管理的重要性以及几种常见的实现方法。
一、内存管理的重要性1. 资源分配：计算机内存是有限的资源，而运行在计算机上的应用程序需要占用一定的内存空间。
内存管理的任务是根据应用程序的需要，合理地分配内存资源，以确保每个应用程序都有足够的内存可用，避免出现内存不足的情况。
2. 提高性能：优化内存的使用可以提高系统的性能。
内存管理中的页面置换策略和内存映射等技术可以使应用程序能够更高效地利用内存资源，减少内存碎片和访问延迟，提升系统的运行效率。
3. 进程隔离与保护：内存管理通过为每个进程分配独立的内存空间，实现了进程之间的隔离和保护。
这样，即使一个进程出现错误或崩溃，也不会对其他进程产生影响，提高了系统的可靠性和稳定性。
二、内存管理的实现方法1. 地址空间分配：操作系统通过将逻辑地址空间映射到物理地址空间来管理内存。
逻辑地址空间是应用程序所看到的地址空间，而物理地址空间是实际的硬件地址空间。
地址空间分配可以通过固定分区、可变分区或虚拟存储器等方式实现。
- 固定分区：将内存空间划分为若干个固定大小的分区，每个分区分配给一个进程。
这种分区方式简单，但不够灵活，容易导致内存碎片问题。
- 可变分区：灵活地分配内存空间，根据进程的需求动态划分分区。
这种分区方式可以减少内存碎片，但需要更复杂的算法和数据结构来管理分区。
- 虚拟存储器：使用虚拟地址空间来访问物理内存。
操作系统将物理内存划分为一系列固定大小的页面，并将页面映射到进程的虚拟地址空间。
这种方式可以提供更大的地址空间和更好的内存利用率。
2. 页面置换：当内存空间不足时，操作系统需要将部分页面从内存中换出，为新的页面腾出空间。
可变式分区分配算法
可变式分区分配算法
1.算法思想
可变式分区分配算法的核心思想是按需分配内存空间。
当一个作业需要被加载到内存中时，系统会根据作业的大小，在空闲内存空间中寻找一个合适的分区进行分配。
为了找到合适的分区，系统会按照分区的大小进行排序，然后从小到大或从大到小的顺序遍历分区表，直到找到一个足够大的分区。
分区分配完成后，系统会将剩余的空闲内存空间再次进一步划分为分区。
2.算法步骤
(1)初始化内存空间，将整个内存空间划分成一个初始的大分区，将其添加到分区表中；
(2)当一个作业需要被加载到内存时，系统遍历分区表，选择一个足够大的分区进行分配；
(3)如果找到了一个足够大的分区，则将作业加载到该分区，并更新分区表；
(4)如果没有足够大的分区，则进行内存紧缩操作，为新作业腾出足够大的内存空间，并将其加载到该分区中；
(5)更新分区表，将剩余的空闲内存空间继续划分为一个或多个新的分区；
(6)重复步骤2~5，直到所有作业都被加载到内存中。
3.算法优缺点
然而，可变式分区分配算法也存在一些缺点。
首先，它需要频繁地进行内存分配和释放操作，导致内存分配时间较长。
其次，由于分区的大小不固定，可能会出现外部碎片问题。
此外，可变式分区分配算法还会引入一定的开销，包括分区表和分区管理等。
总结起来，可变式分区分配算法能够灵活地为作业分配合适的内存空间，有效地利用内存资源。
然而，它也存在一些问题，如内存分配时间较长和可能出现的外部碎片问题。
在实际应用中，可以根据具体情况选择合适的存储管理算法，达到更好的性能和效果。
在可变分区存储管理中,最优适应分配算法
在可变分区存储管理中,最优适应分配算法
最优适应分配算法(optimal fit algorithm)是可变分区存储管理中常用的算法，它是以一种有效而实用方式来利用磁盘存储空间的技术，目的是使用最小的空间来存放最多的文件。
一、算法简介
最优适应分配算法是在可变分区存储管理系统中应用最多的一种有效算法。
它通过寻找和利用未被利用的空间，有效地管理存储空间，减少内存的浪费。
此算法的基本原理是比较进程的内存空间需求和当前空闲分区的剩余空间，选择一个空闲分区分配给进程，使得分配的这块空间刚好能够满足进程的内存空间需求。
二、算法的优势
1、空间利用率高：最优适应分配算法做了色样的优化，通过对比空闲区和进程大小，可以在多个空闲区中选择一个最合适的空间来分配，这就有效地将空闲分区完全利用起来。
2、降低内存碎片：最优适应分配算法在进行存储空间的分配时，给每一个进程的存储空间要求满足有效利用完可用的空闲分区，这样就可以有效地降低内存碎片的影响。
3、处理时间短暂：最优适应分配算法虽然空间利用率高，但是相对地，其耗费的时间是少的，因此，这种算法可以满足时间要求，确保效率。
三、应用情况
最优适应分配算法主要用于可变分区存储管理技术，这种技术可以有效地管理大量文件，而不会浪费空间。
而且现在，这种算法已经被广泛应用于嵌入式系统中，专家们尤其是在嵌入式系统设计中广泛地使用最优适应分配算法，以在CPU装入的程序数量、运行程序数量不变的情况下，达到最大的利用空间效果。
计算机四级网络工程师-操作系统原理-第5章内存管理
计算机四级网络工程师-操作系统原理-第5章内存管理计算机四级网络工程师-操作系统原理-第5章内存管理单选题可变分区管理方案，看内存分配表各类适应算法下次适应算法最优适应算法最坏适应算法首次适应算法，系统中剩余的最大空闲分区静态重定位中，从哪个单元获取操作数各类置换算法各类置换算法看内存分配情况表——实战最近最少使用页面置换算法（LRU）先进先出页面置换算法（FIFO）最近最不常用页面置换算法（LFU）最近未使用页面置换算法（NRU）涉及计算【真题讲解】页式管理存储第66题快表命中率花费us计算简单页式存储管理问最大有多少个页面问最大有多少字节问页表长度（页表项个数）写保护中断各个置换算法的缺页率（建议放弃这一题分，比较容易搞混，需要理解各个置换算法并画图表）LRU页面置换算法OPT最佳页面置换算法八进制的计算（先八进制转换成二进制再计算）虚拟页式存储管理（求偏移量题目）题目直接给二进制，直接进行数位数偏移题目直接给16进制，转换为二进制后进行数位数偏移虚拟页式的有效位、修改位、访问位、保护位、禁止位单页存放整数变量个数和循环代码计算缺页次数一般情况通解：两个循环次数相乘，除单页个数答案有整数×整数形式使用快表和不使用快表相比较，求平均访问时间降低x%需要直接记忆单选多选题需要直接记忆多选单选题可变分区管理方案，看内存分配表下次适应算法最优适应算法最坏适应算法首次适应算法，系统中剩余的最大空闲分区这种题目一定要学习画图，画出变化趋势和具体数值静态重定位中，从哪个单元获取操作数第28题：在操作系统的存储系统中，程序装入时采用静态重定位方法。
已知：第18号单元外有一条加法指令，该指令要求处第066号单外取得操作数1234。
假设存储管理为程学分配的内存区域是众第800号开始，则加法指令将从哪一个单元获取操作数：答案——866置换算法策略先进先出页面置换算法（FIFO）将驻留在内存中时间最长的一页调出最先装入内存的一页调出最近最少使用页面置换算法（LRU）最长时间未被使用过的页面距离现在最长时间没有被访问的页面最近最不常用页面置换算法（LFU）一段时间单页面被使用的次数多少选择一段确定的周期T内，使用次数最少最近未使用页面置换算法（NRU）在最近的一个【时钟滴答】中尽量置换一个没有被访问的和没有被修改过的页面理想页面置换算法(OPT）以后不再需要的、或者在最长时间以后才会用到的页面第二次机会页面置换算法检查进入内存时间最久页面的R位，如果是0，则置换该页；如果是1，就将R位清0，并把该页面放到链表的尾端，修改其进入时间【重点就是会放到链表尾端，画图表时注意】各类置换算法各类置换算法看内存分配情况表——实战最近最少使用页面置换算法（LRU）先进先出页面置换算法（FIFO）最近最不常用页面置换算法（LFU）最近未使用页面置换算法（NRU）涉及计算【真题讲解】页式管理存储第60题：在分区管理方法中，假设程序A自60K处开始存放，到124K为止。
可变分区存储管理
沈阳工程学院学生实验报告（课程名称：操作系统）实验题目：可变分区存储管理班级计算机131 学号********** 姓名杨光成地点实训F608 指导教师吕海华王黎明实验日期: 2015 年 5 月19 日cin>>flag;free(flag);}else if(choice==0) break; //退出else //输入操作有误{cout<<"输入有误，请重试！"<<endl;continue;}}}图12、分配主存（如图2）Status alloc(int ch)}}图23、首次适应(如图3)Status First_fit(int request){//为申请作业开辟新空间且初始化DuLinkList temp=(DuLinkList)malloc(sizeof(DuLNode));temp->data.size=request;temp->data.state=Busy;DuLNode *p=block_first->next;while(p){if(p->data.state==Free && p->data.size==request)图34、最佳适应（如图4和图5）Status Best_fit(int request){int ch; //记录最小剩余空间DuLinkList temp=(DuLinkList)malloc(sizeof(DuLNode));temp->data.size=request;temp->data.state=Busy;DuLNode *p=block_first->next;DuLNode *q=NULL; //记录最佳插入位置while(p) //初始化最小空间和最佳位置{if(p->data.state==Free && (p->data.size>=request) ){q->prior=temp;q->data.address+=request;q->data.size=ch;return OK;}return OK;}图4图55、最差适应（如图6）Status Worst_fit(int request){int ch; //记录最大剩余空间DuLinkList temp=(DuLinkList)malloc(sizeof(DuLNode));temp->data.size=request;temp->data.state=Busy;DuLNode *p=block_first->next;DuLNode *q=NULL; //记录最佳插入位置while(p) //初始化最大空间和最佳位置{if(p->data.state==Free && (p->data.size>=request) )q->prior->next=temp;q->prior=temp;q->data.address+=request;q->data.size=ch;return OK;}return OK;}图6图76、主存回收和显示主存分配情况（如图8）Status free(int flag){DuLNode *p=block_first;for(int i= 0; i <= flag; i++)if(p!=NULL)p=p->next;elsereturn ERROR;p->data.state=Free;if(p->prior!=block_first && p->prior->data.state==Free)//与前面的空闲块相连{cout<<"++++++++++++++++++++++++++++++++++++++++++++++\n\n";DuLNode *p=block_first->next;cout<<"分区号\t起始地址\t分区大小\t状态\n\n";while(p){cout<<" "<<flag++<<"\t";cout<<" "<<p->data.address<<"\t\t";cout<<" "<<p->data.size<<"KB\t\t";if(p->data.state==Free) cout<<"空闲\n\n";else cout<<"已分配\n\n";p=p->next;}cout<<"++++++++++++++++++++++++++++++++++++++++++++++\n\n"; }图8。
分区存储管理的种类
分区存储管理的种类
分区存储管理主要有以下几种类型：
1. 固定分区：这种类型的分区是将内存固定地划分为若干个大小不等的分区，供各个程序使用。
每个分区的大小和位置都固定，系统运行期间不再重新划分。
这种管理方式适用于单用户、单任务系统。
2. 可变分区：这种类型的分区是根据程序的需求动态地分配内存空间。
系统会在空闲内存中寻找合适大小的分区分配给程序。
可变分区管理方式能够适应不同程序的内存需求，但可能导致内存碎片问题。
3. 动态创建分区：这种分区管理方式是根据程序的申请要求动态地分配内存空间。
优点是没有内部碎片，但缺点是有外部碎片（难以利用的小空闲分区）。
4. 重定位分区：这种类型的分区管理方式是在程序运行时，将程序的逻辑地址转换为物理地址。
当程序需要访问内存时，系统会找到对应物理地址的数据或指令。
这种管理方式适用于多道程序运行的系统。
5. 页式存储管理：这种类型的分区管理方式是将内存划分为固定大小的页面，程序可以分散在不同的页面中。
页面可以动态分配和回收，
从而减少内存碎片。
页式存储管理具有无外部碎片的优点，但可能存在内部碎片问题。
总之，不同的分区存储管理方式有各自的优缺点和适用场景。
在实际应用中，可以根据具体需求和硬件条件选择合适的分区管理方式。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
此代码很有用共有1人认为此代码有用可变分区存储管理方案中的内存分配YuChao发布于2010年11月24日22时(0评) 4人收藏此代码，我要收藏(?)用户提出内存空间的申请；系统根据申请者的要求，按照一定的分配策略分析内存空间的使用情况，找出能满足请求的空闲区，分给申请者；当程序执行完毕或主动归还内存资源时，系统要收回它所占用的内存空间或它归还的部分内存空间。
1．程序运行时首先接收输入：空闲区数据文件，包括若干行，每行有两个数据项：起始地址、长度（均为整数），各数据项以逗号隔开。
2．建立空闲区表并在屏幕上显示输出空闲区表内容，空闲区表中记录了内存中可供分配的空闲区的始址和长度，用标志位指出该分区是否是未分配的空闲区。
3．从用户界面根据用户提示接收一个内存申请，格式为：作业名、申请空间的大小。
4．按照最差（最坏）适配算法选择一个空闲区，分割并分配，修改相应的数据结构（空闲区表），填写内存已分配区表（起始地址、长度、标志位），其中标志位的一个作用是指出该区域分配给哪个作业。
5．重复3、4，直到输入为特殊字符（0）。
6．在屏幕上显示输出新的空闲区表和已分配区表的内容。
本程序包括:FIFO,最优适应分配算法,最坏适应算法#include<stdio.h>#include<iostream.h>#include<string.h>#include<iomanip.h>const int MAXJOB=100;//定义表最大记录数typedef struct node{int start;int length;char tag[20];}job;job frees[MAXJOB];//定义空闲区表int free_quantity;job occupys[MAXJOB];//定义已分配区表int occupy_quantity;//初始化函数void initial(){int i;for(i=0;i<MAXJOB;i++){frees[i].start=-1;frees[i].length=0;strcpy(frees[i].tag,"free");occupys[i].start=-1;occupys[i].length=0;strcpy(occupys[i].tag,"");}free_quantity=0;occupy_quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];cout<<"请输入初始空闲表文件名:"; cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%d,%d",&frees[free_quantity].start,&frees[free_quantity].l ength);free_quantity++;}return 1;}return 0;}//sortvoid sort(){int i,j,p;for(i=0;i<free_quantity-1;i++){p=i;for(j=i+1;j<free_quantity;j++){if(frees[j].start<frees[p].start){p=j;}}if(p!=i){frees[free_quantity]=frees[i];frees[i]=frees[p];frees[p]=frees[free_quantity];}}}//显示函数void view(){int i;cout<<endl<<"----------------------------------------------------------"<<endl;cout<<"当前空闲表:"<<endl;cout<<"起始地址长度状态"<<endl;for(i=0;i<free_quantity;i++){cout.setf(2);cout.width(12);cout<<frees[i].start;cout.width(10);cout<<frees[i].length;cout.width(8);cout<<frees[i].tag<<endl;}cout<<endl<<"----------------------------------------------------------"<<endl;cout<<"当前已分配表:"<<endl;cout<<"起始地址长度占用作业名"<<endl;for(i=0;i<occupy_quantity;i++){cout.setf(2);cout.width(12);cout<<occupys[i].start;cout.width(10);cout<<occupys[i].length;cout.width(8);cout<<occupys[i].tag<<endl;}}//最先适应分配算法void earliest(){char job_name[20];int job_length;int i,j,flag,t;cout<<"请输入新申请内存空间的作业名和空间大小:";cin>>job_name;cin>>job_length;flag=0;for(i=0;i<free_quantity;i++){if(frees[i].length>=job_length){flag=1;}}if(flag==0){cout<<endl<<"Sorry,当前没有能满足你申请长度的空闲内存,请稍候再试"<<endl;}else{t=0;i=0;while(t==0){if(frees[i].length>=job_length){t=1;}i++;}i--;occupys[occupy_quantity].start=frees[i].start;strcpy(occupys[occupy_quantity].tag,job_name);occupys[occupy_quantity].length=job_length;occupy_quantity++;if(frees[i].length>job_length){frees[i].start+=job_length;frees[i].length-=job_length;}else{for(j=i;j<free_quantity-1;j++){frees[j]=frees[j+1];}free_quantity--;cout<<"内存空间成功:)"<<endl;}}}//最优适应分配算法void excellent(){char job_name[20];int job_length;int i,j,flag,t;cout<<"请输入新申请内存空间的作业名和空间大小:";cin>>job_name;cin>>job_length;flag=0;for(i=0;i<free_quantity;i++){if(frees[i].length>=job_length){flag=1;}}if(flag==0){cout<<endl<<"Sorry,当前没有能满足你申请长度的空闲内存,请稍候再试"<<endl;}else{t=0;i=0;while(t==0){if(frees[i].length>=job_length){t=1;}i++;}i--;for(j=0;j<free_quantity;j++){if((frees[j].length>=job_length)&&(frees[j].length<frees[i].length)){ i=j;}}occupys[occupy_quantity].start=frees[i].start;strcpy(occupys[occupy_quantity].tag,job_name);occupys[occupy_quantity].length=job_length;occupy_quantity++;if(frees[i].length>job_length){frees[i].start+=job_length;frees[i].length-=job_length;}else{for(j=i;j<free_quantity-1;j++){frees[j]=frees[j+1];}free_quantity--;cout<<"内存空间成功:)"<<endl;}}}//最坏适应算法void worst(){char job_name[20];int job_length;int i,j,flag,t;cout<<"请输入新申请内存空间的作业名和空间大小:";cin>>job_name;cin>>job_length;flag=0;for(i=0;i<free_quantity;i++){if(frees[i].length>=job_length){flag=1;}}if(flag==0){cout<<endl<<"Sorry,当前没有能满足你申请长度的空闲内存,请稍候再试"<<endl;}else{t=0;i=0;while(t==0){if(frees[i].length>=job_length){t=1;}i++;}i--;for(j=0;j<free_quantity;j++){if((frees[j].length>=job_length)&&(frees[j].length>frees[i].length)){ i=j;}}occupys[occupy_quantity].start=frees[i].start;strcpy(occupys[occupy_quantity].tag,job_name);occupys[occupy_quantity].length=job_length;occupy_quantity++;if(frees[i].length>job_length){frees[i].start+=job_length;frees[i].length-=job_length;else{for(j=i;j<free_quantity-1;j++){frees[j]=frees[j+1];}free_quantity--;cout<<"内存空间成功:)"<<endl;}}}//撤消作业void finished(){char job_name[20];int i,j,flag,p=0;int start;int length;cout<<"请输入要撤消的作业名:";cin>>job_name;flag=-1;for(i=0;i<occupy_quantity;i++){if(!strcmp(occupys[i].tag,job_name)){flag=i;start=occupys[i].start;length=occupys[i].length;}}if(flag==-1){cout<<"没有这个作业名"<<endl;}else{//加入空闲表for(i=0;i<free_quantity;i++){if((frees[i].start+frees[i].length)==start){if(((i+1)<free_quantity)&&(frees[i+1].start==start+length)){ frees[i].length=frees[i].length+frees[i+1].length+length;for(j=i+1;j<free_quantity;j++){frees[j]=frees[j+1];}free_quantity--;p=1;else{frees[i].length+=length;p=1;}}if(frees[i].start==(start+length)){frees[i].start=start;frees[i].length+=length;p=1;}}if(p==0){frees[free_quantity].start=start;frees[free_quantity].length=length;free_quantity++;}//删除分配表中的该作业for(i=flag;i<occupy_quantity;i++){occupys[i]=occupys[i+1];}occupy_quantity--;}}//显示版权信息函数void version(){cout<<endl<<endl;cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<<endl; cout<<" ┃可变分区存储管理模拟系统┃"<<endl; cout<<" ┠───────────────────────┨"<<endl; cout<<" ┃(c)All Right Reserved Neo ┃"<<endl; cout<<" ┃sony006@ ┃"<<endl; cout<<" ┃version 2004 build 1122 ┃"<<endl; cout<<" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"<<endl; cout<<endl<<endl;void main(){int flag=0;int t=1;int chioce=0;version();initial();flag=readData();while(flag==1){sort();cout<<endl<<endl<<"================================================== ======="<<endl;cout<<" 可变分区存储管理模拟系统"<<endl;cout<<"========================================================="<<en dl;cout<<" 1.申请空间 2.撤消作业 3.显示空闲表和分配表 0.退出"<<endl; cout<<"请选择:";cin>>chioce;switch(chioce){case 1://换算法请换下一句调用earliest();break;case 2:finished();break;case 3:view();break;case 0:flag=0;break;default:cout<<"选择错误!"<<endl;}} }。