操作系统(一个小型操作系统的设计与实现)课程设计

1、操作系统课程设计报告南通大学计算机科学与技术学院专业：学生姓名：学号：时间：操作系统课程设计报告操作系统模拟算法课程设计报告设计要求将本学期三次的实验集成实现：A. 处理机管理；B. 存储器管理；C. 虚拟存储器的缺页调度。设计流程图主流程图开始的图形界面 存储器管理缺页调度处理机管理LRU算法先进先出最佳适应法首次适应法先来先服务时间片轮转A.处理机调度 1)先来先服务FCFS开始初始化进程控制块，让进程控制块按进程到达先后顺序让进程排队调度数组中首个进程，并让数组中的下一位移到首位计算并打印进程的完成时刻、周转时间、带权周转时间其中：周转时间 = 完成时间 - 到达时间带权周转时间=周转时

2、间/服务时间更改计时器的当前时间,即下一刻进程的开始时间当前时间=前一进程的完成时间+其服务时间数组为空NY结束 先来先服务算法流程2)时间片轮转法时间片轮转算法流程图B.存储器管理(可变式分区管理） 1)首次适应法 分配流程图开始申请xkb内存由链头找到第一个空闲区分区大小xkb？大于分区大小=分区大小-xkb，修改下一个空闲区的后向指针内容为（后向指针）+xkb;修改上一个空闲区的前向指针为（前向指针）+xkb将该空闲区从链中摘除：修改下一个空闲区的后向地址=该空闲区后向地址，修改上一个空闲区的前向指针为该空闲区的前向指针等于小于延链查找下一个空闲区到链尾了？作业等待返回是否登记已分配表返

3、回分配给进程的内存首地址首次适应算法回收流程图 开始输入完成进程的标号在分配区表中查找释放区p下邻分区空闲区前一个空闲区的后向指针指向p的后一个分区，p的后一个分区的前向指针指向p的前一个分区，且p的前一个分区大小更改为加上p的大小，释放p释放区p上邻分区空前一个分区的后向指针指向p的后一个空闲分区，p的后一个空闲分区的前向指针指向p的前一个分区，且p的后一个分区大小更改为加上p的大小释放区p上下均邻空闲区前一个空闲区的后向指针指向p的后一个空闲分区，p的后一个空闲分区的前向指针指向p的前一个空闲分区，且p的前一个空闲分区大小更改为加上p的大小再加上p的后一个空闲分区的大小，合并后的这个空闲区

4、的后向指针指向p的下下个分区，如果p的下下个分区不为空，则其前向指针指向合并后的这个空闲区，释放p和p的下一个分区释放区p上下均不邻空闲区将p放在链首，并修改其状态位为空闲2） 最佳适应法开始释放分区与上空闲分区相邻释放分区与下空闲分区相邻 结束释放分区与下空闲分区相邻TFTFTF摘除链表中上分区。合并释放分区与上分区，将上空闲区长度修改为这二分区的长度。摘除链表中上下分区。合并这三个分区，将上空闲区长度修改为三个分区的长度。摘除链表中下分区。合并释放分区与下分区，将释放分区中长度修改为这二分区的长度。将合并的或释放的分区按长度升序重新插入到自由链表中。回收内存流程C.虚拟存储器的缺页调度 1

5、)先进先出FIFO开始FIFO的缺页中断处理查主存分块表有空闲块可用？Y分配一块NJ=pHEADJ的修改标志=1？NY输出“将J页复写入交换区”输出“装入L页”调整FIFO队列，将L插入队尾（HEAD=(HEAD+1)modM)修改主存分块表和页表终止FIFO淘汰算法流程 2）LRU开始LRU的缺页中断处理查主存分块表有空闲块可用？Y分配一块N找到栈底元素：J=pM-1J的修改标志=1？NY输出“将J页送到入交换区”输出“装入L页”调整堆栈，使HEAD所指元素及以下的元素下移PHEAD=L修改主存分块表和页表终止LRU淘汰算法流程实现原理主界面设计一个框架分别去链接处理机管理、存储器管理和缺页

6、调度相关的程序。A.处理机调度 1)先来先服务FCFS（1） 任务先来先服务的调度算法实现处理机调度。（2） 要求1. 实现对FCFS算法的模拟实现2. 计算出该算法的平均作业周转时间、平均带权作业周转时间。（3） 原理按作业到达CPU时间先后顺序进行非剥夺式调度，先到达CPU的作业先被执行。（4） 数据结构 struct task_struct char name; /*进程名称*/ int number; /*进程编号*/ float come_time; /*到达时间*/ float run_begin_time; /*开始运行时间*/ float run_time; /*运行时间*/

7、float run_end_time; /*运行结束时间*/ int priority; /*优先级*/ int order; /*运行次序*/ int run_flag; /*调度标志*/ tasksMAX;int fcfs()/*先来先服务算法*/进程名链接指针到达时间估计运行时间进程状态进程控制块结构（5） 实现方法建立一个链表按照到达CPU的时间从小到大排列，只需从第一个作业（头结点）依次调度到最后一个作业（尾结点）。（6） 运行界面测试数据：作业名到达时间运行时间A028B09C03执行FCFS算法如下： 2)时间片轮转法（1） 任务只对进程的运行模拟，将其运行时间加一，判断要求运行

8、时间与已运行时间是否相等，若相等则表示进程结束，进程退出调度，释放资源。（2） 要求1. 实现对RR算法的模拟实现2. 显示执行完一个时间片的结果。（3） 原理时间片轮转算法中，系统将所有的就程序按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，调度程序停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。（4） 数据结构 temp->state='R' /初始状态每个进程均为运行态 temp->allocation=0;/初始时进程均不占用c

9、pu num+=temp->need_time; /用num来限制循环的次数（5） 实现方法处理器调度总是选择标志单元指示的进程运行。执行：已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位的时间。当一个进程被选中运行时，必须设置该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片 进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。同时，应判断该进程的要求运行时间与已运行时间，若该进程的要求运行时间¹已运行时间，则表示它尚未执行结束，应待到下一轮时再运行。若该进程的要求运行时间=

10、已运行时间，则表示它已经执行结束，应指导它的状态修改成“结束”且退出队列。此时，应把该进程的进程控制块中的指针值送到前面一个进程的指针位置。进程名链接指针到达时间估计运行时间进程状态进程控制块结构（6） 运行界面测试数据：作业号执行时间/sA1B2C1执行时间片轮转算法RR如下：B.存储器管理(可变式分区管理） 1)首次适应法（1） 任务通过采用首次适应算法实现内存的分配与回收，并可以查看和显示当前内存现状。（2） 要求1.实现对FF算法的模拟实现2.输入要进行分配内存的进程ID和相应所需内存大小，回收内存时输入已运行的进程ID。（3） 原理FF算法要求空闲链已地址递增的次序连接。分配内存时，

11、从链首开始顺序查找，直到找到第一个满足要求的空间并分配给进程，把分配后余下的空间仍然留在链表中。若从链首至链尾都不满足要求，则分配失败。该算法倾向于优先使用低地址的空间。（4） 数据结构int const MEMO=256;/初始化常类型MEMO，用MEMO表示内存大小（常类型的变量或对象的值是不能被更新的）struct FreeMemory int ID;int StartAdd;int Size; bool State;/定义state 为布尔型变量，其值只有 真 （TRUE) 和假 （FALSE) FreeMemory* Next;FreeMemory* AllocTable=new F

12、reeMemory;/建立全局管理表用于内与回收FreeMemory* PtrforCycleFit=AllocTable;/为循环首次适应定义的指针，此指针用于指向当前查找的起始地址;/初始化内存函数void MemoryInit(FreeMemory* &tempAdd) tempAdd->ID=0;/初始化当前进程为空 tempAdd->Size=MEMO;/初始化可分配空间为内存大小 tempAdd->StartAdd=0;/初始化起始地址为0 tempAdd->State=false;/ 初始化状态为未分配 tempAdd->Next=NULL;

13、/初始化下一个进程也为空/反馈内存现态void DispMemory() FreeMemory* temp=AllocTable;/全局管理表反映内存状态 cout<<"系统总内存: "<<MEMO<<endl; for(;temp;temp=temp->Next) cout<<"进程ID："<<temp->ID<<" "<<"大小："<<temp->Size<<" "&

14、lt;<"起始地址:"<<temp->StartAdd<<" "<<"是否已分配:"<<temp->State<<endl;/ 输出内存的各个变量（5） 实现方法可变式分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需要，并且分区的个数是可以调整的。当需要装入一个作业时，根据作业需要的贮存量，查看是否有足够的空闲空间，若有，则按需求量分割一部分给作业；若无，则作业等待。随着作业的装入、完成，主存空间被分割成许多大大小小的分区。有的分区被分配作业

15、占用，有的分区空闲。在空闲区表中，按空闲区首地址从低到高进行登记。当一个作业执行完成时，作业所占用的分区应归还给系统。在归还时，要考虑相邻空间区合并问题。作业的释放区与空闲区的邻接分以下4种情况考虑：A、释放区下邻空闲区；B、释放区上邻空闲区；C、释放区上下都与空闲区邻接；D、释放区上邻空闲区不邻接。（6） 运行界面系统总内存为256时，分别为进程1、2、3分配大小为64、128、64的内存。执行首次适应算法分配内存如下：若回收进程2的内存，执行结果如下： 2）最佳适应法（1） 任务通过采用最佳适应算法实现内存的分配与回收，并可以查看和显示当前内存现状。（2） 要求1.实现对BF算法的模拟实现

16、2.输入要进行分配内存的进程ID和相应所需内存大小，回收内存时输入需要回收的内存块。（3） 原理最佳适应算法扫描整个未分配表或链表，从空闲区中挑选一个能满足用户进程要求的最小分区进行分配。此算法保证不会分割一个更大的区域，使得装入大作业的要求容易得到满足，同时，通常把空闲区按长度递增顺序排列，查找时总是从最小的一个空闲区开始，直至找到满足要求的分区为止，这时，最佳适应分配算法等同于首次适应算法。此算法的主存利用率好，所找出的分区如果最好满足要求则是最合适的。（4） 数据结构int const MEMO=256;/初始化常类型MEMO，用MEMO表示内存大小（常类型的变量或对象的值是不能被更新的

17、）struct FreeMemory int ID;int StartAdd;int Size; bool State;/定义state 为布尔型变量，其值只有 真 （TRUE) 和假 （FALSE) FreeMemory* Next;bool Alloc_BestFit(int id,int TrySize)/查找满足此条件的 x1<=TrySize<=x2 的分区,然后将其放置在x2中，并将x2拆分成两个分区 SortPartition(true);/使用快速排序算法，升序排序for(;temp;temp=temp->Next) /*回收操作,回收过程中，要用到三个指针，

18、上一个Last,当前temp,下一个temp->next 当temp指向表头或表尾时需要特殊考虑*/当要退出工作时,就要回收/此退出的工作由执行函数调用void EndJob(int id) Free_Memory(id);（5） 实现方法空闲区设置为双向链表，其双向链的分区格式为：0（状态位）分区大小（N+2）向前指针大小为N的已分配区或空闲区0（状态位）分区大小（N+2)向后指针（6） 运行界面测试数据如下：进程123456所需内存253445121310执行最佳适应算法为其分配内存如下：若回收进程4，执行结果如下：C.虚拟存储器的缺页调度 1)先进先出FIFO（1） 任务采用先进先

19、出FIFO算法实现分页管理的缺页调度，并输出每次调入调出的页号和运行结果。（2） 要求1.实现对FIFO算法的模拟实现2.输出每次执行的结果。（3） 原理基于程序总是按线性顺序来访问物理空间这一假设，总是淘汰最先调入主存的页面，即淘汰在主存中驻留时间最长的页面，认为驻留时间最长的页不再使用的可能性较大。（4） 数据结构void FIFO()int length;int fifo100=0;int pageLength;int fifoPage100=0;int i,j;cout<<" *先进先出算法*"<<endl;pageLength=3;leng

20、th=9; for(i=1;i<=length;i+)int flag=0;for(j=1;j<=pageLength;j+)if(fifoi=fifoPagej)flag=1;j=pageLength+1;else if(fifoPagej=0)fifoPagej=fifoi;j=pageLength+1;flag=1; if(flag=1)elsecout<<" 淘汰"<<fifoPage1<<endl;for(j=1;j<=pageLength;j+)fifoPagej=fifoPagej+1;fifoPagepa

21、geLength=fifoi;（5） 实现方法当采用先进先出算法时，用一个数组构成先进先出队列，数组中各个元素为进程已在主存的页号，其队列头指针初始化为0.假设分配给每个进程的内存块数固定。当队列满需淘汰时，淘汰最先进入主存的一页。若该页修改过，还有存入磁盘。然后要把当前访问的页装入该块，并修改页表和存储分块表的对应标志。（6） 运行界面测试数据：页表长度：9；页框长度：3；页面请求数列：4,4,3,5,1,1,2,3,2执行先进先出FIFO算法结果如下： 2）LRU（1） 任务采用先进先出LRU算法实现分页管理的缺页调度，并输出每次调入调出的页号和运行结果。（2） 要求1.实现对LRU算法的

22、模拟实现2.输出每次执行的结果。（3） 原理最近最少使用页面替换算法淘汰的页面是在最近一段时间内最久未被访问的那一页，它是基于程序局部性原理来考虑的，认为那些刚被使用过的页面可能还有立即被使用，而那些在较长时间内未被使用的页面可能不会立即使用。在分页虚拟存储系统中，当硬件发出缺页中断后转操作系统处理缺页中断。如果主存中已无空闲块，可采用LRU算法进行缺页处理。（4） 数据结构void LRU()int length;int lru100=0;int pageLength;int lruPage100=0; int i,j;cout<<" *最近最少使用LRU算法*&quo

23、t;<<endl;pageLength=3;length=9; for(i=1;i<=length;i+)int flag=0;for(j=1;j<=pageLength;j+)if(lrui=lruPagej)for(int cc=j;cc>0;cc-)lruPagecc=lruPagecc-1;lruPage1=lrui;flag=1;j=pageLength+1;else if(lruPagej=0)for(int vv=j;vv>0;vv-)lruPagevv=lruPagevv-1;lruPage1=lrui;j=pageLength+1;flag

24、=1; if(flag=1)elsecout<<" 淘汰"<<lruPagepageLength<<endl;for(j=pageLength;j>0;j-)lruPagej=lruPagej-1;lruPage1=lrui;（5） 实现方法当采用LRU算法时，用一个数组构成堆栈，堆栈中各个元素为进程已在主存的页号，为了进行页面置换，可设置一个栈指针，初始化为0.假定分配给每个进程的内存块数固定不变。当队列满需淘汰时，操作系统选择栈底元素淘汰，其他元素向下移一个位置，将新调入页放栈指针指示的栈顶。当访问的页在栈中时，还应调整页从当前

25、位置到栈顶。（6） 运行界面测试数据：页表长度：9；页框长度：3；页面请求数列：2,3,5,1,5,5,4,4,3执行最近最少使用LRU算法结果如下：总结与体会通过本次课程设计让我对于图形界面设计有了一定的思路和看法，同时我对先来先服务、时间片轮转、首次适应算法、最佳适应算法、先进先出和最近最少使用算法有了更详尽的认识。在编程的过程中发现会用到大量的指针，用指针来操作大量的数据比较方便，但最后应该记得释放资源。从这次实验中我发现我对于c+掌握也有所不足，程序经过了多次修改才得以完善，在以后应该注重编程方面的训练。此外我还更深入的理解了各个进程调度算法，及实现过程。在编写程序时查询了很多资料，间

26、接提高了我的搜索能力。在此次课程设计过程中，对进程的相关知识有了一定的加深。特别是对进程的进程控制块的存在和价值有了更进一步的认识。在编写程序的过程之中，对进程自身信息的设计和管理以及调度的算法都有助于对书本知识的理解和掌握。特别是设计先来先服务调度算法和时间片轮转调度算法的时候，对进程的调度算法有了更好的深入理解。对进程管理中的等待队列，就绪队列，时间片等概念有了更深刻的印象。在设计此模拟操作系统的课设中，也加深了对c+知识的把握。解决了一些以往在编程中遇到了困难。通过此次的课程设计，不仅提高了对操作系统的认知，也在同时提高了编程的能力，加强了实践。另外，我觉得此次课程设计虽然主要问题是在编

27、程上，但是经过不断的去调试，还是成功的调试了出来。但是这几个程序用了多天的时间进行分析和修改，虽然出现了不少问题，但收获颇多！源代码：#include<iostream>#include<cstring>#include <cstddef>using namespace std;int fcfsoutput(); /*调度结果输出*/int fcfsinput(); /进程参数的初始化void kaishi();#define MAX 10struct node /建立链表来存放进程数据 char name5; /进程名称 int need_time; /所

28、需要的时间 int allocation; /占用cpu的情况 char state; /目前的状态 R为运行，E为运行完毕 node *next; /链表的尾结点 ;struct task_struct char name; /*进程名称*/ int number; /*进程编号*/ float come_time; /*到达时间*/ float run_begin_time; /*开始运行时间*/ float run_time; /*运行时间*/ float run_end_time; /*运行结束时间*/ int priority; /*优先级*/ int order; /*运行次序*/

29、 int run_flag; /*调度标志*/ tasksMAX;int counter; /*实际进程个数*/int fcfs()/*先来先服务算法*/fcfsinput();float time_temp=0;int i;int number_schedul;time_temp=e_time;for(i=0;i<counter;i+) tasksi.run_begin_time=time_temp; tasksi.run_end_time=tasksi.run_begin_time+tasksi.run_time; tasksi.run_flag=1; time_

30、temp=tasksi.run_end_time; number_schedul=i; tasksnumber_schedul.order=i+1;fcfsoutput();return 0;int fcfsinput() task_struct tt; int i,j; /初始化进程数 counter=3; /初始化每个到达系统的时间为5、7、8 e_time=rand()%9; e_time=rand()%9; e_time=rand()%9; for(i=1;i<3;i+) for(j=0;j<3-i;j+) if(

31、e_time>tasksj+1.come_time) tt=tasksj; tasksj=tasksj+1; tasksj+1=tt; /初始化每个进程估计运行的时间 tasks0.run_time=28; tasks1.run_time=9; tasks2.run_time=3; /初始化每个进程的名字='A'='B'='C'cout<<"*先来先服务算法*"<<endl<<endl;for(i=0

32、;i<counter;i+) tasksi.run_begin_time=0; tasksi.run_end_time=0; tasksi.order=0; tasksi.run_flag=0;return 0;int fcfsoutput() /*调度结果输出*/int i;float turn_round_time=0,f1,w=0;cout<<"作业名 到达时间 运行时间 开始时间 停止时间 运行次序 周转时间"<<endl;for(i=0;i<counter;i+) f1=tasksi.run_end_time-tasksi.co

33、me_time; turn_round_time+=f1; w+=(f1/tasksi.run_time); cout<<" "<<<<'t'<<" "<<e_time<<'t'<<" " <<tasksi.run_time<<'t'<<" "<<tasksi.run_begin_time<

34、<'t'<<" " <<tasksi.run_end_time<<'t'<<tasksi.order<<'t'<<f1<<'t'<<endl;cout<<"平均周转时间："<<turn_round_time/counter<<endl;cout<<"平均带权周转时间："<<w/counter<<end

35、l;cout<<" "return 0;/*-*/int rr()int n=3,num=0;node *head=NULL;node *tail=NULL;cout<<"*时间片轮转调度算法*"<<endl<<endl;for(int i=0;i<n;i+) node *temp=new node;if(i=0)strcpy(temp->name,"A");if(i=1)strcpy(temp->name,"B");if(i=2)strcpy(te

36、mp->name,"C"); temp->need_time=rand()%4+1; temp->state='R' /初始状态每个进程均为运行态 temp->allocation=0;/初始时进程均不占用cpu num+=temp->need_time; /用num来限制循环的次数 if(!head) tail=head=temp; else tail->next=temp; tail=temp; tail->next=head; node *p;p=head;cout<<endl<<&qu

37、ot;初始时刻："<<endl;cout<<"进程"<<'t'<<"剩余时间"<<'t'<<"占用cpu时间"<<endl;while(p!=tail)cout<<" "<<p->name<<'t'<<" "<<p->need_time<<'t'<&l

38、t;'t'<<p->allocation<<'s'<<endl;p=p->next;cout<<" "<<tail->name<<'t'<<" "<<tail->need_time<<'t'<<'t'<<p->allocation<<'s'<<endl;node *q;int

39、label=1;int m=1;while(label=1&&m<=num)cout<<endl;label=0; while(!p->need_time) p=p->next; if(p->need_time) p->need_time-;p->allocation+; if(p->need_time=0) p->state='E' label=1;p=p->next; cout<<"执行"<<m<<"秒后："<&

40、lt;endl; q=head; cout<<"进程"<<'t'<<"剩余时间"<<'t'<<"占用cpu时间"<<endl; while(q!=tail) cout<<" "<<q->name<<'t'<<" "<<q->need_time<<'t'<<'t

41、'<<q->allocation<<'s'<<endl; q=q->next; cout<<" "<<tail->name<<'t'<<" "<<tail->need_time<<'t'<<'t'<<q->allocation<<'s'<<endl; m+;cout<<en

42、dl<<" "return 0;/*-*/int const MEMO=256;/初始化常类型MEMO，用MEMO表示内存大小（常类型的变量或对象的值是不能被更新的）struct FreeMemory int ID;int StartAdd;int Size; bool State;/定义state 为布尔型变量，其值只有 真 （TRUE) 和假 （FALSE) FreeMemory* Next;FreeMemory* AllocTable=new FreeMemory;/建立全局管理表用于内存分配与回收FreeMemory* PtrforCycleFit=Al

43、locTable;/为循环首次适应定义的指针，此指针用于指向当前查找的起始地址;/初始化内存函数void MemoryInit(FreeMemory* &tempAdd) tempAdd->ID=0;/初始化当前进程为空 tempAdd->Size=MEMO;/初始化可分配空间为内存大小 tempAdd->StartAdd=0;/初始化起始地址为0 tempAdd->State=false;/ 初始化状态为未分配 tempAdd->Next=NULL;/初始化下一个进程也为空/反馈内存现态void DispMemory() FreeMemory* temp

44、=AllocTable;/全局管理表反映内存状态 cout<<"系统总内存: "<<MEMO<<endl; for(;temp;temp=temp->Next) cout<<"进程ID："<<temp->ID<<" "<<"大小："<<temp->Size<<" "<<"起始地址:"<<temp->StartAdd<

45、<" "<<"是否已分配:"<<temp->State<<endl;/ 输出内存的各个变量/分区排序void SortPartition(bool order)/在此使用的是快速排序算法FreeMemory* temp1=AllocTable;FreeMemory* temp2=AllocTable;FreeMemory* Last1=temp1;FreeMemory* Last2=temp2;if(temp2->Next)temp2=temp2->Next; switch(order) cas

46、e 1:/升序部分 for(;temp1;temp1=temp1->Next) for(;temp2;temp2=temp2->Next) if(temp1->Size> temp2->Size)&&!temp1->State&&!temp2->State)/找到符合条件的，则交换 Last1->Next=temp2; Last2->Next=temp1; FreeMemory* temp=temp2->Next; temp2->Next=temp1->Next; temp1->Nex

47、t=temp->Next; Last2=temp2; Last1=temp1; break; case 0:/降序部分 for(;temp1;temp1=temp1->Next) for(;temp2;temp2=temp2->Next) if(temp1->Size < temp2->Size)&&!temp1->State&&!temp2->State)/找到符合条件的，则交换 Last1->Next=temp2; Last2->Next=temp1; FreeMemory* temp=temp2-

48、>Next; temp2->Next=temp1->Next; temp1->Next=temp->Next; Last2=temp2; Last1=temp1; /*内存分配*/bool Alloc_FirstFit(int id, int TrySize)/ 定义布尔型函数Alloc_FirstFit()/查找一个可用第一个满足分配请求的分区，如果满足将其写入内存分配表/否则分配失败，返回 FreeMemory* temp=AllocTable;for(;temp;temp=temp->Next) if(TrySize<=temp->Size

49、 && !temp->State)/第一个满足条件的分区已找到 if(TrySize=temp->Size)/刚好和申请的大小一致 temp->ID=id; /保持不变temp->Next,Size,StartAdd都不用变 temp->State=true; /值为真表示已分配 else/比所找到的要小，则需要将其拆分 FreeMemory* NewItem=new FreeMemory; NewItem->Next=temp->Next; NewItem->ID=0; NewItem->Size=temp->Siz

50、e-TrySize; NewItem->StartAdd=temp->StartAdd+TrySize; NewItem->State=false; temp->ID=id; temp->Size=TrySize; temp->State=true; temp->Next=NewItem; return true; /end forreturn false;bool Alloc_BestFit(int id,int TrySize)/查找满足此条件的 x1<=TrySize<=x2 的分区,然后将其放置在x2中，并将x2拆分成两个分区 So

51、rtPartition(true);/使用快速排序算法，升序排序FreeMemory* temp=AllocTable;if(temp->Next)temp=temp->Next;for(;temp;temp=temp->Next) if(TrySize<=temp->Size && !temp->State)/第一个满足条件的分区已找到 if(TrySize=temp->Size)/刚好和申请的大小一致 temp->ID=id; /保持不变temp->Next,Size,StartAdd都不用变 temp->Stat

52、e=true; /值为真表示已分配 else/比所找到的要小，则需要将其拆分 FreeMemory* NewItem=new FreeMemory; NewItem->Next=temp->Next; NewItem->ID=0; NewItem->Size=temp->Size-TrySize; NewItem->StartAdd=temp->StartAdd+TrySize; NewItem->State=false; temp->ID=id; temp->Size=TrySize; temp->State=true; te

53、mp->Next=NewItem; return true; /end for return false; bool Alloc_Memory(int id, int Algorithm,int TrySize)/对算法进行选择 switch(Algorithm) case 1 : return Alloc_FirstFit(id,TrySize); break; case 2: return Alloc_BestFit(id,TrySize); break; default: cout<<"你没有指定算法,系统将默认为首次适应算法!"<<endl; return Alloc_FirstFit(id,TrySize); /*End Memory Alloc 内存分配区操作定义完成*/ /*Recycle Memory 回收内存*/bool Free_Memory(int id) FreeMemory* temp=AllocTable; FreeMemory* Last=temp;