计算机操作系统内存分配实验源代码

#include<stdio.h>#include<iostream>usingnamespace std;#define MEM_SIZE 200staticchar mem[MEM_SIZE];#define MINBLK 16struct block {struct block * next;size_t length;char data[0];};staticstruct block * free_list = NULL;//free_list为空void malloc_init(void){free_list = (struct block *)mem;free_list->next = NULL;//next指向空free_list->length = MEM_SIZE - sizeof(struct block);//data段的长度}//字节对齐void * malloc(size_t size){size = (size + 7) & ~7;struct block * prev = (struct block *) &free_list;//block首段struct block * cur = free_list;//cur 指向空闲的块while (cur != NULL) {if (cur->length >= size) //判断cur指向的块是否满足所要求的大小break;prev = cur;cur = cur->next;}if (cur == NULL)return NULL;//cur->length(data段的长度)-size后的大小可不可以放下blockif ((cur->length - size) >= MINBLK) {struct block * temp = (struct block *)(cur->data + size);//temp指向新block的头temp->next = cur->next;//新block指向下一个空白temp->length = cur->length - size - sizeof(struct block);prev->next = temp;cur->length = size;}else {prev->next = cur->next;}return cur->data;}void free(void * ptr){if (ptr == NULL)return;struct block * temp = (struct block *)((char *)ptr - sizeof(struct block));char * tempn = (char *)ptr + temp->length; // 和temp物理上相邻的下一个block的地址struct block * prev = (struct block *) &free_list;struct block * cur = free_list;char * curn; // 和cur物理上相邻的下一个block的地址// 考虑多种情况，完成free函数// ... ...if (free_list > temp)//空块地址大于要释放的块的地址，直接将释放的块放入空白块头部（第一种情况）{if (((char*)temp + sizeof(block)+temp->length) == (char*)free_list) {temp->length += sizeof(block)+free_list->length;free_list = temp;}else {temp->next = free_list;free_list = temp;}ptr = NULL;return;}//若不一定插入头部，寻找插入块while (cur != NULL && (char*)cur < (char*)temp){prev = cur;cur = cur->next;}//temp与前段free_list相邻if (((char *)prev + sizeof(struct block) + prev->length) == (char*)temp){prev->length =prev->length + sizeof(struct block) + temp->length;temp = prev;ptr = NULL;}else{prev->next = temp;ptr = NULL;}//free_list在比temp地址大的地方且两者相邻if ((char *)tempn == (char *)cur || cur == NULL){temp->next = cur->next;temp->length = sizeof(struct block) + cur->length + temp->length;ptr = NULL;}else{temp->next = cur;ptr = NULL;}}void malloc_state(void){printf("free blocks:\n");struct block * ptr;for (ptr = free_list; ptr != NULL; ptr = ptr->next) {int i;printf("%p:", ptr);//printf("%d", ptr->length);for (int i = 0; i < ptr->length; i++) {printf("=");}printf(" ");}printf("\n");}void malloc_test(void){//定义abcdef为分配状态char* a = (char*)malloc(sizeof(char));malloc_state();char* b = (char*)malloc(sizeof(char));malloc_state();char* c = (char*)malloc(sizeof(char));malloc_state();char* d = (char*)malloc(sizeof(char));malloc_state();char* e = (char*)malloc(sizeof(char));malloc_state();char* f = (char*)malloc(sizeof(char));//按照adbfec的顺序进行释放会将所有的情况包含进去malloc_state();free(a);malloc_state();free(d);malloc_state();free(b);malloc_state();free(f);malloc_state();free(e);malloc_state();free(c);malloc_state();}int main(int argc, constchar *argv[]) {malloc_init();malloc_test();system("pause");return 0;}。

第1篇一、实验目的1. 理解操作系统内存分配的基本原理和常用算法。

2. 掌握动态分区分配方式中的数据结构和分配算法。

3. 通过编写程序，实现内存分配和回收功能。

二、实验环境1. 操作系统：Linux2. 编程语言：C语言3. 开发工具：GCC编译器三、实验原理1. 内存分配的基本原理操作系统内存分配是指操作系统根据程序运行需要，将物理内存分配给程序使用的过程。

内存分配算法主要包括以下几种：（1）首次适应算法（First Fit）：从内存空间首部开始查找，找到第一个满足条件的空闲区域进行分配。

（2）最佳适应算法（Best Fit）：在所有满足条件的空闲区域中，选择最小的空闲区域进行分配。

（3）最坏适应算法（Worst Fit）：在所有满足条件的空闲区域中，选择最大的空闲区域进行分配。

2. 动态分区分配方式动态分区分配方式是指操作系统在程序运行过程中，根据需要动态地分配和回收内存空间。

动态分区分配方式包括以下几种：（1）固定分区分配：将内存划分为若干个固定大小的分区，程序运行时按需分配分区。

（2）可变分区分配：根据程序大小动态分配分区，分区大小可变。

（3）分页分配：将内存划分为若干个固定大小的页，程序运行时按需分配页。

四、实验内容1. 实现首次适应算法（1）创建空闲分区链表，记录空闲分区信息，包括分区起始地址、分区大小等。

（2）编写分配函数，实现首次适应算法，根据程序大小查找空闲分区，分配内存。

（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。

2. 实现最佳适应算法（1）创建空闲分区链表，记录空闲分区信息。

（2）编写分配函数，实现最佳适应算法，根据程序大小查找最佳空闲分区，分配内存。

（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。

3. 实验结果分析（1）通过实验，验证首次适应算法和最佳适应算法的正确性。

（2）对比两种算法在内存分配效率、外部碎片等方面的差异。

五、实验步骤1. 创建一个动态内存分配模拟程序，包括空闲分区链表、分配函数和回收函数。

WinCE5.0中VirtualAlloc内存分配的试验代码⼀、引WINCE HELP中对VirtualAlloc的说明⾥，对第⼀个参数pAddress描述⾥写到“If the memory is being reserved, the specified address is rounded down to the next 64-KB boundary. If the memory is reserved and is being committed, the address is rounded down to the next page boundary. ” 如果不是上⾯提到这篇⽂章，我根本就不会注意到这句，因为TCPMP⾥的⽤法是：p = VirtualAlloc(NULL,n,MEM_COMMIT,PAGE_READWRITE);这第⼀个参数根本就忽略过去了。

下⾯的代码试验是基于这篇⽂章的。

其中我最担⼼的⼀点，就是⽂章是针对的，⽽⽬前我⽤的版本是5.0，⽂中所提到的⼀些限制，是否已经有所改进了呢。

⼆、测试64KB对齐的直接分配⽅式写个测试代码验证⼀下#include "stdafx.h"#include "Winbase.h"#include "stdlib.h"int WINAPI WinMain( HINSTANCE hInstance,HINSTANCE hPrevInstance,LPTSTR lpCmdLine,int nCmdShow){// TODO: Place code here.int i = 0;void* pMem = NULL;SYSTEM_INFO SystemInfo;GetSystemInfo(&SystemInfo);printf("SystemInfo.dwPageSize = %d \n", SystemInfo.dwPageSize);printf("SystemInfo.lpMinimumApplicationAddress = 0x%x \n", (int)SystemInfo.lpMinimumApplicationAddress);printf("SystemInfo.lpMaximumApplicationAddress = 0x%x \n", (int)SystemInfo.lpMaximumApplicationAddress);GlobalMemoryStatus(&MemStatus);printf("MemStatus.dwTotalPhys = %d \n", MemStatus.dwTotalPhys);printf("MemStatus. dwAvailPhys = %d \n", MemStatus.dwAvailPhys);printf("MemStatus.dwTotalVirtual = %d \n", MemStatus.dwTotalVirtual);printf("MemStatus.dwAvailVirtual = %d \n", MemStatus.dwAvailVirtual);while(1){pMem = VirtualAlloc (0, 512, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);if(!pMem){printf("alloc %d times, failed, end",i+1);break;}else{printf("0x%X ",(int)pMem);}i++;}GlobalMemoryStatus(&MemStatus);printf("MemStatus.dwTotalPhys = %d \n", MemStatus.dwTotalPhys);printf("MemStatus. dwAvailPhys = %d \n", MemStatus.dwAvailPhys);printf("MemStatus.dwTotalVirtual = %d \n", MemStatus.dwTotalVirtual);printf("MemStatus.dwAvailVirtual = %d \n", MemStatus.dwAvailVirtual);return 1;}运⾏结果：SystemInfo.dwPageSize = 4096SystemInfo.lpMinimumApplicationAddress = 0x10000SystemInfo.lpMaximumApplicationAddress = 0x7fffffffMemStatus.dwTotalPhys = 55,656,448MemStatus.dwAvailPhys = 40,923,136MemStatus.dwTotalVirtual = 33,554,4320x60000 0x70000 0x80000 0x900000xA0000 0xB0000 0xC0000 0xD0000......0x1E40000 0x1E50000 0x1E60000 0x1E700000x1E80000 0x1E90000 0x1EA0000 0x1EB0000alloc 487 times to failed, ENDMemStatus.dwTotalPhys = 55,656,448MemStatus.dwAvailPhys = 38,903,808MemStatus.dwTotalVirtual = 33,554,432MemStatus.dwAvailVirtual = 0很好，和⾼级内存管理⼀⽂描述的情况⼀样, 不过还是有些意外的发现. 我们再来仔细看⼀下(1) 所谓的next 64-KB boundary，换算成16进制也就是0x10000, 上⾯测试代码所得到的结果，的确是每次分配按0x10000递增的(2) 的确在分配不⾜512次后，内存就⽤光了，分配失败停⽌了。

内存分配实验代码-回复内存分配实验代码：探索动态内存分配的原理与过程引言在计算机程序设计中，内存分配是至关重要的一环。

动态内存分配是指在程序运行时根据需要分配和释放内存空间。

它可以帮助开发人员灵活地管理资源，提高程序的效率和性能。

本文将以实验代码为主题，一步一步解释内存分配的原理与过程，并介绍常用的动态内存分配函数。

读者可以通过这篇文章理解内存分配的机制，并在实际开发过程中更好地进行内存管理。

1. 实验代码介绍实验代码是一个简单的C语言程序，用于模拟内存分配的过程。

以下是代码的核心部分：#include <stdio.h>#include <stdlib.h>int main() {int *ptr;int size;printf("请输入需要分配的内存大小：");scanf("d", &size);ptr = (int*)malloc(size * sizeof(int)); 动态内存分配if (ptr == NULL) {printf("内存分配失败！\n");return 1;}printf("成功分配了d个int型变量的内存\n", size);printf("内存地址：0xp\n", ptr);free(ptr); 释放内存printf("释放了d个int型变量的内存\n", size);return 0;}以上代码通过调用`malloc`函数动态分配了一个指定大小的内存空间，并通过`free`函数释放了分配的内存。

通过运行这段代码，我们可以观察内存分配的过程和结果，了解内存分配的实现细节。

2. 动态内存分配原理动态内存分配是通过在程序运行时从操作系统获取一块连续的内存空间。

C语言中，我们可以通过调用`malloc`函数来进行动态内存分配。

#define OK 1 // 完成#define ERROR 0 // 出错 typedef int Status; typedef struct free_table// 定义一个空闲区说明表结构{int num; // 分区序号 long address; // long length; //int state; // }ElemType; typedef struct Node// { ElemType data; struct Node *prior; // struct Node *next; // 起始地址分区大小 分区状态 线性表的双向链表存储结构 前趋指针 后继指针}Node,*LinkList;LinkList first; // 头结点LinkList end; // 尾结点int flag;// 记录要删除的分区序号Status Initblock()// 开创带头结点的内存空间链表{first=(LinkList)malloc(sizeof(Node));end=(LinkList)malloc(sizeof(Node));first->prior=NULL;first->next=end;end->prior=first;end->next=NULL;end->=1;end->=40;end->=600;end->=0;return OK;void sort()// 分区序号重新排序{Node *p=first->next,*q;q=p->next;for(;p!=NULL;p=p->next) {for(q=p->next;q;q=q->next){if(p->>=q->{q->+=1;}}}}// 显示主存分配情况void show(){ int flag=0;// 用来记录分区序号Node *p=first;p->=0;p->=0;p->=40;p->=1;sort();printf("\n\t\t 》主存空间分配情况《\n");printf("**********************************************************\n\n");printf（" 分区序号\t 起始地址\t 分区大小\t 分区状态\n\n"）;while(p){printf("%d\t\t%d\t\t%d",p->,p->,p->;if(p->==0) printf("\t\t 空闲\n\n");else printf("\t\t 已分配\n\n");{p=p->next; printf("**********************************************************\n\n"); }// 首次适应算法Status First_fit(int request){// 为申请作业开辟新空间且初始化Node *p=first->next;LinkList temp=(LinkList)malloc(sizeof(Node));temp->=request;temp->=1;p->=1;while(p)if((p->==0)&&(p->==request)){// 有大小恰好合适的空闲块p->=1;return OK;break;}else if((p->==0) && (p->>request)){// 有空闲块能满足需求且有剩余temp->prior=p->prior; temp->next=p;temp->=p->;temp->=p->;p->prior->next=temp; p->prior=temp;p->=temp->+temp->;p->=request;p->+=1;return OK;break;}p=p->next;}return ERROR;}// 最佳适应算法Status Best_fit(int request){int ch; // 记录最小剩余空间Node *p=first;Node *q=NULL; // 记录最佳插入位置LinkList temp=(LinkList)malloc(sizeof(Node)); temp->=request;temp->=1;p->=1;while(p) // 初始化最小空间和最佳位置{if((p->==0) && (p->>=request) ){if(q==NULL){q=p;ch=p->;}else if(q-> > p->{q=p;ch=p->;}p=p->next;}if(q==NULL) return ERROR;//没有找到空闲块else if(q->==request){q->=1;return OK;}else{temp->prior=q->prior;temp->next=q;temp->=q->;temp->=q->;q->prior->next=temp;q->prior=temp;q->+=request;q->=ch;q->+=1;return OK;}return OK;}// 最差适应算法Status Worst_fit(int request){int ch; // 记录最大剩余空间Node *p=first->next;Node *q=NULL; // 记录最佳插入位置LinkList temp=(LinkList)malloc(sizeof(Node));temp->=request;temp->=1;p->=1;while(p) // 初始化最大空间和最佳位置{if(p->==0 && (p->>=request) ){if(q==NULL){q=p;ch=p->;}else if(q-> < p->{q=p;ch=p->;}p=p->next;}if(q==NULL) return ERROR;//没有找到空闲块else if(q->==request){q->=1;return OK;}else{temp->prior=q->prior;temp->next=q;temp->=q->;temp->=q->;q->prior->next=temp;q->prior=temp;q->+=request;q->=ch;q->+=1;return OK;}return OK;}// 分配主存Status allocation(int a){int request;// 申请内存大小printf(" 请输入申请分配的主存大小(单位:KB):"); scanf("%d",&request);if(request<0 ||request==0){printf(" 分配大小不合适，请重试！");return ERROR;}switch(a){case 1: // 默认首次适应算法if(First_fit(request)==OK) printf("\t**** 分配成功！****");else printf("\t**** 内存不足，分配失败！****");return OK;break;case 2: // 选择最佳适应算法if(Best_fit(request)==OK) printf("\t**** 分配成功！****");else printf("\t**** 内存不足，分配失败！****");return OK;break;case 3: // 选择最差适应算法if(Worst_fit(request)==OK) printf("\t**** else printf("\t****分配成功！****");内存不足，分配失败！****"); return OK;break;}}Status deal1(Node *p)// 处理回收空间{Node *q=first;for(;q!=NULL;q=q->next){if(q==p){if(q->prior->==0&&q->next->!=0){q->prior->+=q->;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->=0;q->=flag-1;}if(q->prior->!=0&&q->next->==0) {q->+=q->next->;q->next=q->next->next;q->next->next->prior=q;q->=0;q->=flag;}if(q->prior->==0&&q->next->==0) {q->prior->+=q->;q->prior->next=q->next; q->next->prior=q->prior; q=q->prior;q->=0;q->=flag-1;}if(q->prior->!=0&&q->next->!=0){q->=0;}}}return OK;}Status deal2(Node *p)// 处理回收空间Node *q=first;for(;q!=NULL;q=q->next){if(q==p){if(q->prior->==0&&q->next->!=0){q->prior->+=q->;q->prior->next=q->next;q->next->prior=q->prior;q=p->prior;q->=0;q->=flag-1;}if(q->prior->!=0&&q->next->==0)q->=0;} if(q->prior->==0&&q->next->==0){q->prior->+=q->;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->=0;q->=flag-1;}if(q->prior->!=0&&q->next->!=0){q->=0;}}return OK;}// 主存回收Status recovery(int flag){Node *p=first;for(;p!=NULL;p=p->next){if(p->==flag){if(p->prior==first){if(p->next!=end)// 当前P 指向的下一个不是最后一个时{if(p->next->==0) // 与后面的空闲块相连{p->+=p->next->;p->next->next->prior=p;p->next=p->next->next;p->=0;p->=flag;}else p->=0;}if(p->next==end)// 当前P 指向的下一个是最后一个时{p->=0;}}// 结束if(p->prior==block_first) 的情况else if(p->prior!=first)if(p->next!=end){deal1(p);}else{deal2(p);}}// 结束if(p->prior!=block_first)的情况}// 结束if(p->==flag) 的情况}printf("\t**** 回收成功****");return OK;}// 主函数void main(){int i; // 操作选择标记int a;// 算法选择标记printf(" f******************************************************** **\n");printf("\t\t 用以下三种方法实现主存空间的分配\n");printf("\t(1) 首次适应算法\t(2) 最佳适应算法\t(3) 最差适应算法\n");printf(" f********************************************************* *\n");printf("\n");printf(" 请输入所使用的内存分配算法:");scanf("%d",&a);while(a<1||a>3){printf(" 输入错误，请重新输入所使用的内存分配算法:\n");scanf("%d",&a);}switch(a)case1:printf("\n\t**** case 2:printf("\n\t**** case 3:printf("\n\t**** 使用首次适应算法：使用最佳适应算法：使用最坏适应算法：}Initblock(); // 开创空间表while(1){show();printf("\t1: 分配内存\t2: 回收内存\t0: printf(" 请输入您的操作：");scanf("%d",&i);if(i==1)allocation(a); // 分配内存****\n");break; ****\n");break; ****\n");break;退出\n");else if(i==2) // 内存回收printf(" 请输入您要释放的分区号："); scanf("%d",&flag);recovery(flag);}else if(i==0){printf("\n 退出程序\n");break; // 退出}else // 输入操作有误{printf(" 输入有误，请重试！"); continue;八、执行结果和结果分析初始化首次适应算法：当作业1、2、3 顺利分配内存空间后：}回收序号 2 里面的内存：分配作业4：回收序号 3 里面的内存（与上邻序号2相连了）回收序号 1 里的内存（与下邻序号 2 相连了）继续分配（会发现总是按顺序查找满足要求的第一个空闲块，一旦发现就会分配）。

内存分配算法实验代码好的，下面是一个简单的内存分配算法的示例代码，使用了最先适配（First Fit）算法来分配内存：```pythonclass MemoryAllocator:def __init__(self, memory_size):self.memory_size = memory_sizeself.memory_map = [0] * memory_sizedef allocate_memory(self, size):if size > self.memory_size:return -1for i in range(0, self.memory_size - size + 1):if self.memory_map[i] == 0:self.memory_map[i:i + size] = [1] * sizereturn ireturn -1def free_memory(self, address, size):if address < 0 or address + size > self.memory_size:return -1self.memory_map[address:address + size] = [0] * size# 示例用法memory_allocator = MemoryAllocator(1024)address = memory_allocator.allocate_memory(128)print("分配的内存地址：", address)memory_allocator.free_memory(address, 128)```在上述示例中，我们定义了一个 `MemoryAllocator` 类，它使用最先适配算法来管理内存分配。

类中的 `allocate_memory` 方法用于分配指定大小的内存，它会遍历内存映射数组，找到第一个连续的空闲区域，并将其分配给请求的内存。

#include<stdio.h>#include<stdlib.h>#define NUM 128typedef struct{ int zm_no;int cd_no;int jl_no;}disk;void disp(int m[]){int i;printf("位?示º?图ª?：êo\n");for(i=0;i<NUM;i++){if(i%8==0)printf("\n");printf("%d\t",m[i]);}printf("\n");}void creat(int m[]){ int j=0,zh,wh;int keyong=0;while(j<NUM){ if(m[j]==0){ keyong=1;m[j]=1;disk a;a.zm_no=j/8;a.cd_no=(j%8)/4;a.jl_no=(j%8)%4;zh=a.zm_no;wh=a.cd_no*4+a.jl_no;printf("柱¨´面?号?\t磁ä?道̨¤号?\t物?理¤¨ª记?录?号?\n");printf("%d\t%d\t%d\n",a.zm_no,a.cd_no,a.jl_no);printf("字Á?号?\t位?号?\n");printf("%d\t%d\n",zh,wh);break;}else j++;}if(keyong==0){ printf("无T可¨¦用®?磁ä?盘¨¬块¨¦！ê?\n");printf("\n");}}void del(int m[]){ disk b;int zm_no,cd_no,jl_no,j;printf("输º?入¨?待äy回?收º?磁ä?盘¨¬块¨¦的Ì?柱¨´面?号?，ê?磁ä?道̨¤号?，ê?物?理¤¨ª记?录?号?：êo");scanf("%d%d%d",&b.zm_no,&b.cd_no,&b.jl_no);j=8*b.zm_no+4*b.cd_no+b.jl_no;if(m[j]==0)printf("已°?是º?空?闲D状Á¡ä态¬?，ê?不?必À?回?收º?！ê?\n");else{ m[j]=0;disp(m);}}int main(){int i;int input=1;int m[NUM]={ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1};while(input!=0){ printf("1.当Ì¡À前¡ã磁ä?盘¨¬状Á¡ä态¬? 2.申¦¨º请?磁ä?盘¨¬块¨¦ 3.回?收º?磁ä?盘¨¬块¨¦ 0.退ª?出?\n");scanf("%d",&input);switch(input){ case 1: disp(m);break;case 2: creat(m);break;case 3: del(m);break;default:break;}}system("pause");return 0;}。

#include<stdio.h>#include<stdlib.h>#define FF 0#define BF 1typedef struct JCB//作业结构体{int ads;int size;int id;struct JCB *next;}JCB,*JCBStr;typedef struct{JCBStr front;JCBStr end;}Link;Link Ready,Free;//已分配和未分配队列int Type;//内存分配操作int Size;//内存总大小int Fit;//内存分配方法int adress;//临时地址void build(JCBStr &q)//创建空链节{q = (JCBStr) malloc(sizeof(JCB));q->next = NULL;}void create(JCBStr &q,int id)//创建一个JCB {build(q);q->id = id;q->size = Size;q->ads = adress;}void Init()//队列初始化{build(Ready.front);Ready.end = Ready.front;build(Free.front);Free.end = Free.front;JCBStr q;create(q,0);Free.front->next = q;Free.end = q;q->ads = 0;}void lookFree(JCBStr &q)//查看空闲队列{JCBStr s,t;s = Free.front;t = Free.front->next;while(t){if(t->size>=Size){adress = t->ads;break;}s = t;t = t->next;}q = t;if(t && Fit == BF){s->next = t->next;if(t == Free.end)Free.end = s;}}void lookReady(JCBStr &q,int id)//查看并取出链节{JCBStr s;s = Ready.front;q = Ready.front->next;while(q){if(q->id == id)break;s = q;q = q->next;}if(!q) return;q->id = 0;s->next = q->next;if(q == Ready.end)Ready.end = s;}void insertReadyLink(JCBStr &q)//插入分配队列{Ready.end->next = q;Ready.end = q;}void InsertFreeBF(JCBStr &q)//根据内存空间排序插入{JCBStr s,t;t = Free.front;s = Free.front->next;while(s){if(s->size <= q->size){t = s;s = s->next;}else{break;}}t->next = q;q->next = s;if(t == Free.end)Free.end = q;}void InsertFreeFF(JCBStr &q)//根据内存地址排序插入{JCBStr s,t;t = Free.front;s = Free.front->next;while(s){if(s->ads < q->ads){t = s;s = s->next;}else{break;}}t->next = q;q->next = s;if(t == Free.end)Free.end = q;}void hebinFF(JCBStr &q,JCBStr &node,int type)//快速回收查找方法{JCBStr s,t;s = Free.front;t = s->next;switch(type){case 0:while(t){if(t->ads + t->size < q->ads){s = t;t = t->next;}else if(t->ads+t->size == q->ads){node = t;s->next = t->next;if(t == Free.end)Free.end = s;break;}else{node = NULL;break;}}break;case 1:while(t){if(q->ads+q->size < t->ads){s = t;t = t->next;}else if(q->ads+q->size == t->ads){node = t;s->next = t->next;if(t == Free.end)Free.end = s;break;}else{node = NULL;break;}}break;}}void hebinBF(JCBStr &q,JCBStr &node,int type)//最优回收{JCBStr s,t;node = NULL;s = Free.front;t = s->next;switch(type){case 0:while(t){if(t->ads+t->size != q->ads){s = t;t = t->next;}else{node = t;s->next = t->next;if(t == Free.end)Free.end = s;break;}}break;case 1:while(t){if(q->ads+q->size != t->ads){s = t;t = t->next;}else{node = t;s->next = t->next;if(t == Free.end)Free.end = s;break;}}break;}}void hebin(JCBStr &node,JCBStr &node1,int type)//回收合并方法{if(node1!=NULL){switch(type){case 0:node->ads -= node1->size;node->size +=node1->size;free(node1);break;case 1:node->size += node1->size;free(node1);break;}}}int buildLink(int id,int type,int fit) //内存分配回收{JCBStr node,node1;switch(type){case 1://内存分配lookFree(node);//查看满足空间的内存，不取出if(!node) return 0;switch(fit){case FF:create(node1,id);//创建Ready节点insertReadyLink(node1);//放入队列node->ads += Size;//空闲节点地址增加node->size -=Size;//节点空间减少break;case BF:create(node1,id);//创建Ready节点insertReadyLink(node1);//放入队列node->ads += Size;//空闲节点地址增加node->size -=Size;//节点空间减少InsertFreeBF(node);//按空间大小排序插入队列break;}break;case 2://内存回收lookReady(node,id);if(!node) return 0;switch(fit){case FF://合并hebinFF(node,node1,0);hebin(node,node1,0);hebinFF(node,node1,1);hebin(node,node1,1);//直接插入InsertFreeFF(node);break;case BF://合并hebinBF(node,node1,0);hebin(node,node1,0);hebinBF(node,node1,1);hebin(node,node1,1);//排序插入空闲队列InsertFreeBF(node);break;}break;}return 1;}//输出void print(Link Q){JCBStr p;p=Q.front->next;if(p==NULL)printf("# 队列为空!#\n");//队列为空else{printf("# 分区号起始大小#\n");while(p!=NULL) //否则显示队列中所有元素{printf(" %d %d %d \n",p->id,p->ads,p->size);p=p->next;}}}int main(){int id,flag;printf("##########################################\n");printf("# 请输入总内存大小#\n");printf("##########################################\n");scanf("%d",&Size);Init();//printf("########################################\n");printf("#选择内存分配策略，0 ：首次适应算法（first fit）;1 :最佳适应算法（best fit）#\n");//printf("########################################\n");scanf("%d",&Fit);//printf("########################################\n");printf("#选择内存操作，1 :分配内存，2 :内存回收,0 退出程序！#\n");//printf("# #\n");while(scanf("%d",&Type),Type!=0){switch(Type){case 1:printf("请输入内存分配编号和所需内存大小！\n");scanf("%d%d",&id,&Size);flag = buildLink(id,Type,Fit);if(flag == 0)printf("内存空间不足！\n");else{printf("回收成功！已分配内存为：\n");print(Ready);printf("剩余内存为：\n");print(Free);}break;case 2:printf("请输入内存回收编号！\n");scanf("%d",&id);flag = buildLink(id,Type,Fit);if(flag == 0)printf("此编号不存在！\n");else{printf("回收成功！已分配内存为：\n");print(Ready);printf("剩余内存为：\n");print(Free);}break;}//printf("########################################\n");printf("#选择内存操作，1 :分配内存，2 :内存回收,0 退出程序！#\n");// printf("#0 退出程序！#\n");//printf("########################################\n");}return 0;}。

西安邮电大学（计算机学院）课内实验报告实验名称：内存管理专业名称：软件工程班级：学生姓名：学号（8位）：指导教师：实验日期：实验五：进程1.实验目的通过深入理解区管理的三种算法，定义相应的数据结构，编写具体代码。

充分模拟三种算法的实现过程，并通过对比，分析三种算法的优劣。

（1）掌握内存分配FF，BF，WF策略及实现的思路；（2）掌握内存回收过程及实现思路；（3）参考给出的代码思路，实现内存的申请、释放的管理程序，调试运行，总结程序设计中出现的问题并找出原因，写出实验报告。

2.实验要求：1）掌握内存分配FF，BF，WF策略及实现的思路；2）掌握内存回收过程及实现思路；3）参考本程序思路，实现内存的申请、释放的管理程序，调试运行，总结程序设计中出现的问题并找出原因，写出实验报告。

3.实验过程：创建进程：删除其中几个进程：(默认以ff首次适应算法方式排列)Bf最佳适应算法排列方式：wf最差匹配算法排列方式：4.实验心得：这次实验实验时间比较长，而且实验指导书中对内存的管理讲的很详细，老师上课的时候也有讲的很详细，但是代码比较长，刚开始的时候也是不太懂，但是后面经过和同学一起商讨，明白几种算法的含义：①首次适应算法。

在采用空闲分区链作为数据结构时，该算法要求空闲分区链表以地址递增的次序链接。

在进行内存分配时，从链首开始顺序查找，直至找到一个能满足进程大小要求的空闲分区为止。

然后，再按照进程请求内存的大小，从该分区中划出一块内存空间分配给请求进程，余下的空闲分区仍留在空闲链中。

②循环首次适应算法。

该算法是由首次适应算法演变而形成的，在为进程分配内存空间时，从上次找到的空闲分区的下一个空闲分区开始查找，直至找到第一个能满足要求的空闲分区，并从中划出一块与请求的大小相等的内存空间分配给进程。

③最佳适应算法将空闲分区链表按分区大小由小到大排序，在链表中查找第一个满足要求的分区。

④最差匹配算法将空闲分区链表按分区大小由大到小排序，在链表中找到第一个满足要求的空闲分区。