C语言基本分页存储管理
分页存储管理
谢谢
块
（物理）块或页框。
块号
对分号的若干个物理块分配的编号，每个块号在内存都有对 应物理地址。
31
页表的作用：实现从页号到物理块号的 地址结构 地址映射
12 11
0
第 1 部分-分页存储管理方式
31
12 11 0
就是页内地 址
地址结构
如果逻辑地址空间是2^m，页面大 小是2^n（字节），那么逻辑地址的高 m-n位是页号，低n位是页内地址（即位 移量W），最多允许拥有的页面数是 2^m-n（页） 两部分的地址长度为32位，其中0～11 位（计12位）为位移量,12~31位（计
1
第 3 部分 分段存储管理方式
为每个分段分配一个连续的分区，而进 程中的各个段可以离散地移入内存不同 的分区中。 动态分 配方式 分段存储管 理系统
系统为整个进程分配一个 为了能从物理内存中找出每个逻辑段所对应的位置，引 连续的内存空间 入段表 段表：实现逻辑段到物理内存区的映射。
第 3 部分 分段存储管理方式
与分页存
√
相似之处
两者都采用离散分配方式， 且都要通过地址映射机构来 实现地址变换。
储管理方
×
式的比较
段的作业地址空间则是二维的。
第 3 部分 分段存储管理方式
每段分配一个连续的分区，进程 中的各个段可以离散地分配到内存 中不同的分区中。
3
每个段从0开始编址，采用一 段连续的地址空间。
2
程序地址空间按其内在逻辑关系划分 成若干个相对独立ห้องสมุดไป่ตู้段，如主程序段、 子程序段、数据段及堆栈段等。
课堂回顾
分页存储管理 分段存储管理
关硕 20152069
分页存储回顾
C语言内存使用详解
C语言内存使用详解C语言是一种低级语言，开发者可以直接控制内存使用。
了解C语言内存使用的机制和技巧对于编写高效、安全和可靠的程序至关重要。
本文将详细介绍C语言内存使用的知识和技术，并提供一些实用的建议。
在C语言中，内存是以字节为单位进行管理的，通常将内存分为栈和堆两种。
栈是一种自动分配和自动释放内存的数据结构。
它的特点是后进先出（LIFO），即最后分配的内存最先释放。
栈主要用于存储局部变量、函数参数和函数调用的上下文信息。
在函数调用结束后，分配给局部变量的内存会自动释放。
堆是一种动态分配内存的数据结构，程序员可以手动分配和释放内存。
堆的管理需要调用系统提供的函数，如malloc(和free(。
堆主要用于存储动态分配的数据，如数组、结构体和指针。
程序员需要手动管理堆内存，确保及时释放不再使用的内存，否则会造成内存泄漏。
为了更好地使用内存，提高程序的性能和可靠性，下面是一些C语言内存使用的技巧和注意事项：1.使用局部变量：局部变量是保存在栈上的，它们的生命周期与函数的调用关系密切相关。
局部变量不仅可以节约内存，还可以提高程序的执行效率。
2.合理分配静态变量和全局变量：静态变量和全局变量在程序执行过程中一直存在，它们的生命周期不受函数调用的影响。
过多的静态变量和全局变量会占用大量的内存，影响程序的性能。
3. 动态分配内存时要检查返回值：在调用malloc(等动态分配内存的函数时，要检查返回值是否为NULL。
如果返回值为NULL，表示没有足够的内存可用。
处理内存分配失败的情况至关重要，可以提前终止程序或采取其他恰当的措施。
4. 及时释放不再使用的内存：动态分配的内存在不再使用时要及时释放，以避免内存泄漏。
使用free(函数将内存返回给系统，以供其他程序使用。
5.防止指针错误：指针是C语言中非常重要的概念，但也容易出现指针错误，如空指针引用、越界访问等。
使用指针时要特别小心，确保指针正确地指向有效的内存区域。
3用C语言模拟实现可变式分区存储管理
3用C语言模拟实现可变式分区存储管理可变式分区存储管理是一种动态分配内存空间的方式，它能够根据进程的内存需求来动态地分配和回收内存空间，提高内存的利用率。
在C语言中，我们可以使用指针和数据结构来模拟实现可变式分区存储管理。
1.使用结构体来表示内存块首先，我们可以定义一个结构体来表示每个内存块的属性，包括起始地址、大小、以及是否被占用等信息。
```cstruct Blockint start_address;int size;int is_allocated; // 0代表未分配，1代表已分配};```2.初始化内存空间接下来，我们可以定义一个数组来表示整个内存空间，该数组的每个元素都是一个 Block 结构体，表示一个内存块。
在程序开始时，我们可以初始化一个 Block 数组，表示整个内存空间的初始状态。
```c#define TOTAL_SIZE 1024 // 内存总大小struct Block memory[TOTAL_SIZE];void init_memormemory[0].start_address = 0;memory[0].size = TOTAL_SIZE;memory[0].is_allocated = 0;```3.分配内存空间当进程需要分配内存空间时，可变式分区存储管理会选择一个合适的内存块来分配给该进程。
我们可以定义一个函数来实现分配内存的过程。
```cint allocate_memory(int size)int i;for (i = 0; i < TOTAL_SIZE; i++)if (!memory[i].is_allocated && memory[i].size >= size)//找到未分配且大小足够的内存块memory[i].is_allocated = 1;memory[i].size -= size;return memory[i].start_address;}}//没有找到合适的内存块return -1;```4.回收内存空间当进程释放已分配的内存空间时，我们需要回收这部分内存，使其变为未分配状态。
分页存储管理
非连续分配方式1．基本内容：页式存储管理基本思想、数据结构、地址转换过程。
段式存储管理以及段页式存储管理。
2．学习要求：；掌握页式存储管理、段式存储管理以及段页式存储管理的实现原理、数据结构、地址转换机构等内容。
3．教学要求：本单元共安排4学时。
采用教员课堂讲授方法实施教学。
该部分内容抽象，是本章学习重点与难点。
课后可通过课程设计使学员加深对于抽象理论的理解和掌握。
4．重点：各种管理实现原理、数据结构、地址转换机构。
5．难点：段式存储管理。
分页存储管理可重定位分区分配虽然可以解决碎片和共享问题，但由于信息的大量移动而损失了许多宝贵的CPU时间，且存储用户的作业受到实际存储容量的限制。
多重分区分配虽在一定程度上解决了这些问题，但由于要求各分区设置分段的重定位寄存器，存储分配策略较复杂，且需较多的硬件支持。
分页式管理技术通过地址转换机制，能明显消除内、外存之间的差别，将外存看作内存的扩充和延伸。
并能很好解决“外零头”的问题。
一、分页在储管理实现的基本思想：在分页存储管理中，将每个作业的逻辑地址空间分为大小相同的块，称为虚页面或页（page）,通常页面大小为2的整数次幂（512K~4K）。
同样地，将物理空间也划分为与页面大小相等的块，称之为存储块或页框（page frame），为作业分配存储空间时，总是以页框为单位。
例如：一个作业的地址空间有M页，那么只要分配给它M个页框，每一页分别装入一个页框即可。
纯分页系统的定义：指在调度一个作业时，必须把它的所有页一次装入到主存的矾框。
若当时页框数不足，则该作业必须等待，系统再调度其他作业。
这里，并不要求这些页框是相邻的。
即连续逻辑地址空间的页面，通过页面地址转换机构可以映射到不连续的内存块中。
对地址空间的分页是由系统自动进行的，其逻辑地址由相对页号和页内位移量（页内地址）两部分组成（下面a）。
图中设逻辑地址长度为16位，可表示64K的逻辑地址空间。
物理地址也由块号及块内移量（块内地址）两部分组成（下图b）。
操作系统c语言设计程序模拟内存的动态分区内存管理方法。内存分区使用分区(说明)
操作系统c语言设计程序模拟内存的动态分区内存管理方法。
内存分区使用分区(说明)摘要：1.引言2.内存动态分区原理a.内存分区类型b.内存分区算法3.C语言实现内存动态分区管理a.内存分配函数b.内存释放函数c.内存管理函数4.内存动态分区管理的应用a.进程管理b.文件系统5.内存分区管理的优化a.算法改进b.硬件支持6.结论正文：【引言】内存管理是操作系统中的核心功能之一，它负责对系统内存进行有效分配、管理和回收。
在众多内存管理方法中，动态分区管理因其灵活性和高效性而得到了广泛应用。
本文将介绍操作系统中动态分区管理的原理，以及如何使用C语言实现这一管理方法。
【内存动态分区原理】内存动态分区管理主要包括两个方面：内存分区类型和内存分区算法。
a.内存分区类型内存分区通常分为两类：固定大小分区和不固定大小分区。
固定大小分区是指内存中被分配成固定大小的分区，适用于内存需求稳定的场景。
不固定大小分区则根据实际需求进行分配，更加灵活。
b.内存分区算法内存分区算法主要包括首次适应算法（FF）、最佳适应算法（BF）、最坏适应算法（WF）等。
首次适应算法简单、快速分配，但可能导致内存碎片；最佳适应算法尽量使用最小空间满足需求；最坏适应算法则优先使用大内存块，分割后空闲块仍较大。
【C语言实现内存动态分区管理】在C语言中，我们可以通过编写内存分配函数、内存释放函数和内存管理函数来实现内存动态分区管理。
a.内存分配函数内存分配函数负责根据用户请求分配内存。
可以根据内存分区类型和内存分区算法实现。
例如，首次适应算法可以遍历空闲内存块表，找到第一个满足需求的空闲块并进行分配。
b.内存释放函数内存释放函数负责回收不再使用的内存块，将其归还给空闲内存池。
释放内存时，需要确保该内存块之后的内存块不会被误用。
c.内存管理函数内存管理函数负责监控内存使用情况，如内存总量、空闲内存块数量等，以便在必要时进行内存扩容或压缩。
【内存动态分区管理的应用】内存动态分区管理在操作系统中有着广泛应用，如进程管理和文件系统等。
分页存储管理模拟实验程序源代码（C语言）
分页存储管理模拟实验程序源代码（C语言）# include# include# include# define pagesize 8 //页面尺寸大小typedef struct BLOCK //声明一种新类型--物理块类型{int pagenum; //页号int accessed; //访问量，其值表示多久未被访问}BLOCK;int pc; //程序计数器，用来记录对应的页号int n; //缺页计数器，用来记录缺页的次数static int num[320]; //用来存储320条随机数BLOCK block[pagesize]; //定义一大小为8的物理块数组void init(); //程序初始化函数int findExist(int curpage); //查找物理块中是否有该页面int findSpace(); //查找是否有空闲物理块int findReplace(); //查找应予置换的页面void display (); //显示void randam(); //产生320条随机数,显示并存储到num[320] void pagestring(); //显示调用的页面队列void OPT();void LRU();void FIFO();void main(){int select;printf("请输入第一个随机数(0~320):");randam();printf("*****对应的调用页面队列*******\"); pagestring();do{printf("****************************************\"); printf("------1:OPT 2:LRU 3:FIFO 4:退出-----\"); printf("****************************************\"); printf("请选择一种页面置换算法:");scanf("%d",&select);printf("*******************************\");init();switch(select){case 1:printf("最佳置换算法OPT:\");printf("*****************\");OPT();break;case 2:printf("最近最久未使用置换算法LRU:\");printf("*************************\*");LRU();break;case 3:printf("先进先出置换算法FIFO:\");printf("*********************\");FIFO();break;}}while(select!=4);}void init(){for(int i=0;i{block[i].pagenum=-1;block[i].accessed=0;pc=n=0;}}int findExist(int curpage){for(int i=0; i{if(block[i].pagenum == curpage )return i; //检测到内存中有该页面，返回block中的位置}return -1;}int findSpace(){for(int i=0;i<pagesize;i++){if(block[i].pagenum==-1)return i; //找到空闲的block，返回block中的位置}return -1;}int findReplace(){int pos = 0;for(int i=0;i<pagesize;i++){if(block[i].accessed>block[pos].accessed)pos = i; //找到应该置换页面，返回BLOCK中位置}return pos;}void display(){</pagesize;i++)</pagesize;i++)for(int i=0; i{if(block[i].pagenum != -1){printf(" %02d",block[i].pagenum);}}}void randam(){ int flag=0;scanf("%d",&pc);printf("******按照要求产生的320个随机数：*******\");for(int i=0;i<320;i++){num[i]=pc;if(flag%2==0)pc=++pc%320;if(flag==1)pc=rand()%(pc-1);if(flag==3)pc=pc+1+(rand()%(320-(pc+1)));flag=++flag%4;printf(" %03d",num[i]);if((i+1)%10==0)printf("\");}}void pagestring() //显示调用的页面队列,页面号取法为随机数除10取整{for(int i=0;i<320;i++){printf(" %02d",num[i]/10);if((i+1)%10==0)}}void OPT() //最佳替换算法{int exist,space,position;int curpage;for(int i=0;i<320;i++){pc=num[i];curpage=pc/10;exist=findExist(curpage);if(exist==-1){space=findSpace();if(space != -1){block[space].pagenum = curpage; display();n=n+1;}else{for(int k=0;k<pagesize;k++){for(int j=i;j<320;j++){if(block[k].pagenum!= num[j]/10) {block[k].accessed = 1000;} //将来不会用，设置为一个很大数else{block[k].accessed = j;break;}}}position = findReplace();block[position].pagenum = curpage; display();n++;}}}printf("缺页次数:%d\",n);printf("缺页率:%f%%\",(n/320.0)*100); }void LRU() //最近最久未使用算法{int exist,space,position ;int curpage;for(int i=0;i<320;i++){pc=num[i];curpage=pc/10;exist = findExist(curpage);if(exist==-1){ space = findSpace();if(space != -1){block[space].pagenum = curpage;display();n=n+1;}else{position = findReplace();block[position].pagenum = curpage;display();n++;}}elseblock[exist].accessed = -1;//恢复存在的并刚访问过的BLOCK中页面accessed为-1for(int j=0; j{block[j].accessed++;}}printf("缺页次数:%d\",n);printf("缺页率:%f%%\",(n/320.0)*100);}void FIFO() //先进先出算法{int exist,space,position ;int curpage;for(int i=0;i<320;i++){pc=num[i];curpage=pc/10; //转换为页面号exist = findExist(curpage); // 查找物理块中是否有该页面,没有的话，置为-1if(exist==-1){space = findSpace();</pagesize;k++)//查找是否有空的物理块，没有的话，置为-1；有的话，把位置返回if(space != -1){block[space].pagenum=curpage;display();n=n+1;}else{position = findReplace(); // 没有空闲物理块，进行置换block[position].pagenum = curpage;display();n++;block[position].accessed--;}}for(int j=0; jblock[j].accessed++;}printf("缺页次数:%d\",n);printf("缺页率:%f%%\",(n/320.0)*100); }。
分页、分段与段页式存储
分页、分段与段页式存储⼀. 分页存储管理1.基本思想⽤户程序的地址空间被划分成若⼲固定⼤⼩的区域，称为“页”，相应地，内存空间分成若⼲个物理块，页和块的⼤⼩相等。
可将⽤户程序的任⼀页放在内存的任⼀块中，实现了离散分配。
1) 等分内存页式存储管理将内存空间划分成等长的若⼲物理块，成为物理页⾯也成为物理块，每个物理块的⼤⼩⼀般取2的整数幂。
内存的所有物理块从0开始编号，称作物理页号。
2) 逻辑地址系统将程序的逻辑空间按照同样⼤⼩也划分成若⼲页⾯，称为逻辑页⾯也称为页。
程序的各个逻辑页⾯从0开始依次编号，称作逻辑页号或相对页号。
每个页⾯内从0开始编址，称为页内地址。
程序中的逻辑地址由两部分组成：页号P和页内位移量W。
在执⾏⼀个程序之前，内存管理器需要的准备⼯作：1) 确定程序的页数2) 在主存中留出⾜够的空闲页⾯3) 将程序的所有页⾯载⼊主存⾥。
（静态的分页，页⾯⽆需连续）2. 分页存储管理的地址机构页号x位，每个作业最多2的x次⽅页，页内位移量的位数表⽰页的⼤⼩，若页内位移量y位，则2的y次⽅，即页的⼤⼩，页内地址从000000000000开始到2的y次⽅若给定⼀个逻辑地址为A，页⾯⼤⼩为L，则页号P=INT[A/L]，页内地址W=A MOD L3．内存分配相邻的页⾯在内存中不⼀定相邻，即分配给程序的内存块之间不⼀定连续。
对程序地址空间的分页是系统⾃动进⾏的，即对⽤户是透明的。
由于页⾯尺⼨为2的整数次幂，故相对地址中的⾼位部分即为页号，低位部分为页内地址。
4. 页表分页系统中，允许将进程的每⼀页离散地存储在内存的任⼀物理块中，为了能在内存中找到每个页⾯对应的物理块，系统为每个进程建⽴⼀张页表，⽤于记录进程逻辑页⾯与内存物理页⾯之间的对应关系。
页表的作⽤是实现从页号到物理块号的地址映射，地址空间有多少页，该页表⾥就登记多少⾏，且按逻辑页的顺序排列，形如：5. 地址变换页式虚拟存储系统的逻辑地址是由页号和页内地址两部分组成，地址变换过程如图7-3所⽰。
c分页实现方式
c分页实现方式
在 C 语言中，实现分页有多种方式，下面介绍两种常见的方法：
1. 固定大小的分页：
- 定义一个结构体来表示页，包含页的内容和一些元数据，如页号和页内偏移量。
- 分配一个大的缓冲区来存储所有的页。
- 在需要分页时，将数据按照固定大小分成若干页，存储在缓冲区中。
- 通过页号和页内偏移量来访问指定的页。
2. 动态分页：
- 定义一个结构体来表示页，包含页的内容和一些元数据，如页号和页内偏移量。
- 在需要分页时，动态分配每页的内存。
- 将数据存储在分配的页内存中。
- 通过页号和页内偏移量来访问指定的页。
无论使用哪种方式，都需要考虑以下几个方面：
1. 页的大小：根据实际需求和内存情况，选择合适的页大小。
2. 页的管理：需要维护页的元数据，如页号、页内偏移量等。
3. 数据的存储和访问：需要根据页号和页内偏移量来存储和访问数据。
4. 内存管理：在动态分页中，需要注意内存的分配和释放。
这两种方式只是基本的示例，实际的分页实现可能会根据具体需求进行一些优化和扩展。
希望我的回答能够帮助到你，如果你还有其他疑问，请随时向我提问，我将尽力为你解答。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统实验报告姓名：***学号：************学校：清华大学专业：计算机科学与技术班级：2008级—2班基本分页存储管理实验目的连续内存分配方式会形成许多“碎片”，虽然可以通过“紧凑”方法将许多碎片拼接成可用的大块空间，但须为之付出很大开销。
如果允许将一个进程直接分散地装入到许多不相邻接的分区中，则无需再进行“紧凑”。
基于这一思想而产生了离散分配方式。
如果离散分配的基本单位是页，则称为分页存储管理方式；如果离散分配的基本单位是段，则称为分段存储管理方式。
在分页存储管理方式中，如果不具备页面兑换功能，则称为基本的分页存储管理方式，或称为纯分页存储管理方式，它不具备支持虚拟存储器的功能，它要求把每个作业全部装入内存后方能运行。
本实验通过程序模拟操作系统的基本分页存储管理方式，进一步理解这一内存分配方式的原理和特点，加深对理论知识的掌握。
实验要求1、用C语言或Java语言编写程序模拟操作系统对内存的基本分页存储管理方式2、程序要能正确对“内存”进行“分配”和“回收”，能接受用户的输入，显示内存的分配情况，并有一定的容错能力。
3、每个人独立按时完成实验内容。
实验内容本实验假定内存空间已经按块划分，目标程序无需关心内存块大小等底层细节，只需按算法对内存块进行分配即可。
程序应该实现以下功能：1、内存初始化。
假定内存块共有N个，初始化后的内存空间应该有一部分已经被使用，这可以用随机数或程序内部的其他算法完成。
2、程序应该能接受用户输入的进程信息，并为之分配内存，返回分配结果（成功或失败），注意，此处应该考虑到不合法的输入并进行相应处理。
3、程序能回收用户指定的进程所占用的内存空间，因此，程序可能需要为每个进程分配一个唯一的进程号并给出详细的提示信息。
4、能直观合理地显示内存分配情况。
5、程序界面友好，便于操作和查看运行结果。
实验结果实验总结基本分页的思想是比较简单的，而且实验前老师已经给出了一种可行的数据结构来存储程序中需要用到的数据，因此这个实验在构思上是没有多少难度的。
由于程序中主要使用的是数组，操作起来比较方便，不像前两个实验需要用到大量的链表操作。
在这次试验中，我主要遇到了以下一些问题：1、程序刚写完时，记录“内存”中的进程数的变量和当前剩余总内存的变量的值不正确，经检查后发现是在结束进程时没有同时更新这些数据。
2、内存使用情况应该以哪种形式输出以及输出哪些信息。
最终我选择了尽可能详细地输出有用信息，通过空格、空行、对齐等手段尽力使输出格式简洁美观。
比如，在输出每个进程的内存使用情况时，首先输出该进程占用的总内存，然后以统一的对齐方式依次输出各个内存块编号。
当然，对于不同的模块输出的信息也应该不一样，比如，内存初始化结束后应该输出哪个内存块被占用了，否则无法判断后续的内存分配是否正确，但在以后查看内存使用情况时则不必把所有已占用的内存块输出，因为每个进程都会单独把自己占用的内存块显示出来。
为了达到这种效果，我使用了一个全局变量作为判断依据，详细情况见附录中代码。
3、程序的容错性。
这是一个容易被忽略的问题。
这个程序起初基本没考虑这个问题，但在后来的调试过程中，逐渐加上了一些基本的容错功能，比如用户在结束某进程时，其输入的进程号可能根本不存在，这时应该给出用户出错提示，并要求用户重新输入，但这里用了一个编程中不太推荐的方式：goto 语句。
总体而言，这次实验还是比较顺利的，没有遇到什么特别难解决的问题。
通过自己编程模拟内存分配，我不仅加深了对这种内存管理方式的理解，也增强了C语言的编程能力。
通过这几次的实验，我感觉手工写一个几百行的程序不像以前那么困难了。
附录#include <stdio.h>#include <windows.h>#define N 100 // 共有100个内存块int process[N][N+1]; // 存放每个进程的页表int block[N]; // 内存块状态标志数组，0：空闲，1：使用int blockCount; // 记录当前内存剩余空间int processCount; // 记录当前进程数bool flag = true;void init();void output();bool createProcess();bool endProcess();void init(){int i, j;// 初始化内存状态标志数组for (i=0; i<N; i++)block[i] = 0;for (i=0; i<20; i++)block[rand()%(N-1)] = 1;blockCount = 0;for (i=0; i<N; i++)if (block[i] == 0)blockCount++;// 初始化存放进程的数组for (i=0; i<N; i++){process[i][0] = 0;for (j=1; j<N; j++)process[i][j] = -1;}processCount = 0;printf("初始化结果如下：");output();flag = false;}void output(){printf("\n内存总量：%d 块, 已用空间：%d 块, 剩余空间：%d 块, 进程总数：%d 个\n", N, N-blockCount, blockCount, processCount);if (flag && blockCount < N){printf("已使用的内存块(%d)：\n", N-blockCount);for (int k=0,count=0; k<N; k++){if (block[k] == 1)printf("%2d ", k, ++count);if (count == 15){putchar('\n');count = 0;}}putchar('\n');}// 输出各进程占用内存详细情况if (processCount > 0){printf("内存详细使用情况如下：\n");for (int i=0; i<N; i++){if (process[i][0] > 0){printf("进程号：%d \n占用内存块(%2d)：", i, process[i][0]);for (int j=1,count=0; j<=process[i][0]; j++){printf("%2d ", process[i][j], count++);if (count == 15){putchar('\n');printf(" ");count = 0;}}putchar('\n');}}}elseprintf("当前内存无进程！\n");/*// 输出空闲内存块if (blockCount > 0){printf("空闲内存块(%d)：\n", blockCount);for (int k=0,count=0; k<N; k++){if (block[k] == 0)printf("%2d ", k, ++count);if (count == 15){putchar('\n');count = 0;}}putchar('\n');}*/putchar('\n');}bool createProcess(){int pid, pages, k = 0;loop:printf("请输入进程号(小于%d)和所需页面数：", N);scanf("%d%d", &pid, &pages);if (pid > 99){printf("错误！进程号过大！\n");goto loop;}if (pages > blockCount)return false;blockCount -= pages;process[pid][0] = pages;for (int i=1; i<=pages; i++){while (block[k]==1 && k<100)k++;process[pid][i] = k;block[k] = 1;k++;}processCount++;return true;}bool endProcess(){int pid, pages;if (processCount < 1){printf("当前内存没有进程！\n\n");return false;}printf("当前内存中的进程有%d 个，进程号为：", processCount);for (int i=0; i<N; i++)if (process[i][0] > 0)printf("%2d ", i);putchar('\n');printf("请输入您要结束的进程号(小于%d)：", N);scanf("%d", &pid);pages = process[pid][0];if (pages == 0){printf("对不起！该进程不存在！\n");return false;}for (int j=1; j<pages; j++){block[process[pid][j]] = 0;process[pid][j] = -1;}process[pid][0] = 0;processCount--;blockCount += pages;return true;}void menu(){int choice;while (true){printf("操作菜单：\n");printf(" 1 --> 创建进程\n 2 --> 结束进程\n 3 --> 查看内存\n 0 --> 退出程序\n");printf("请输入您要进行的操作：");scanf("%d", &choice);switch (choice){case 1:if (createProcess())printf("创建新进程成功！\n\n");elseprintf("抱歉！内存空间不足，创建新进程失败！\n\n");break;case 2:if (endProcess())printf("进程已结束！\n\n");elseprintf("进程结束失败！\n\n");break;case 3:output();break;case 0:return ;default:printf("对不起！您的选择有误！请重新选择！\n\n");}}}void main(){init();menu();}11。