操作系统：实验三 动态分区分配算法

最新推荐文章于 2022-08-22 16:32:03 发布
最新推荐文章于 2022-08-22 16:32:03 发布
阅读量1w 收藏 177
点赞数 14
分类专栏： 操作系统 C/C++ 文章标签： 动态分区分配算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wl1780852311/article/details/103085672
版权

一、实验目的
用高级语言编写和调试一个内存连续分配中动态分区分配模拟程序，以加深对进程的概念及进程调度算法的理解．
二、实验指导
设计程序模拟内存动态分区分配流程，要求实现三项功能：分配内存、回收内存、显示内存使用情况
内存连续分配动态分区分配流程图如下
在这里插入图片描述
回收分区时应考虑分区合并的情况，三种情况，如下图
在这里插入图片描述
三、提示
设计程序模拟内存动态分区分配流程，要求如下
1、内存分配表建议使用顺序表或者单链表实现，逻辑结构如下图(a)
2、分区分配算法可以采用首次适应算法、循环首次适应算法、最佳算法之一。
3、假设内存大小为1024K，起始地址为0，都可以被用户程序使用，size数值设为2K
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
#define SIZE 2

typedef struct Memory
{
	int zoning_number;//分区号
	char job_name;//作业名
	int start_address;//起始地址
	int zoning_size;//分区大小
	int state;//状态 （0 1）   1：已分配 2：未分配
} memory;

vector<memory> me;

bool cmp(memory a,memory b)
{
	return a.start_address<b.start_address;
}

void FF()   //首次适应算法
{
	int flag=0;//分配成功 1  失败 0
	memory node;//申请新节点
	//input
	cout<<"作业名(一个字符):";
	char name;
	cin>>name;
	node.job_name=name;
	cout<<"作业占内存大小：";
	int u;
	cin>>u;
	node.zoning_size=u;
	//ff算法
	sort(me.begin(),me.end(),cmp);//地址递增排序
	vector<memory>::iterator it;
	for(it=me.begin(); it!=me.end(); it++)
	{
		if((*it).state==0)   //空闲分区链
		{
			if((*it).zoning_size>u)
			{
				if((*it).zoning_size-u<=2)
				{
					(*it).state=1;//将该分区从空闲链中移除
					(*it).job_name=name;
					flag=1;
					break;
				}
				else     //有空闲块能满足需求且有剩余
				{
					node.zoning_number=(*it).zoning_number;
					node.start_address=(*it).start_address;
					(*it).zoning_number+=1;
					(*it).start_address+=u;
					(*it).zoning_size-=u;
					node.state=1;
					me.insert(it--,node);
					flag=1;
					break;
				}
			}
		}
	}
	if(flag==1)
	{
		cout<<"分配成功！！！"<<endl;
	}
	else
		cout<<"分配失败！！！"<<endl;
}

void recovery()   //回收内存
{
	cout<<"输入要回收分区的作业名(一个字符):";
	char name;
	cin>>name;
	if(me.size()==1)
	{
		me[0].job_name=' ';
		me[0].state=0;
		cout<<"回收成功！！！"<<endl;
		return;
	}
	for(int i=0; i<me.size(); i++)
	{
		if(i==0&&me[i].job_name==name)
		{
			if(me[i+1].state==0)
			{
				me[i].zoning_size+=me[i+1].zoning_size;//合并 回收区与f2
				me[i].state=0;
				me[i].job_name=' ';
				for(int j=i+1; j<me.size()-1; j++)
				{
					me[j].job_name=me[j+1].job_name;
					me[j].start_address=me[j+1].start_address;
					me[j].zoning_size=me[j+1].zoning_size;
					me[j].state=me[j+1].state;
				}
				me.pop_back();
				cout<<"回收成功！！！"<<endl;
				break;
			}
			else
			{
				me[i].job_name=' ';
				me[i].state=0;
				cout<<"回收成功！！！"<<endl;
				break;
			}
		}
		if((i==(me.size()-1))&&me[i].job_name==name)
		{
			if(me[i-1].state==0)
			{
				me[i-1].zoning_size+=me[i].zoning_size;
				me[i-1].job_name=' ';
				me.pop_back();
				cout<<"回收成功！！！"<<endl;
				break;
			}
			else
			{
				me[i].job_name=' ';
				me[i].state=0;
				cout<<"回收成功！！！"<<endl;
				break;
			}
		}
		if(me[i].job_name==name)
		{
			if(me[i-1].state==0&&me[i+1].state==0)
			{
				me[i-1].zoning_size=me[i-1].zoning_size+me[i].zoning_size+me[i+1].zoning_size;
				me[i-1].job_name=' ';
				for(int j=i; j<me.size()-1; j++) //i+1->i i+2->i
				{
					me[j].job_name=me[j+1].job_name;
					me[j].start_address=me[j+1].start_address;
					me[j].zoning_size=me[j+1].zoning_size;
					me[j].state=me[j+1].state;
				}
				me.pop_back();
				for(int j=i; j<me.size()-1; j++) // i+2->i
				{
					me[j].job_name=me[j+1].job_name;
					me[j].start_address=me[j+1].start_address;
					me[j].zoning_size=me[j+1].zoning_size;
					me[j].state=me[j+1].state;
				}
				me.pop_back();
				cout<<"回收成功！！！"<<endl;
				break;
			}
			else if(me[i-1].state==0)
			{
				me[i-1].zoning_size+=me[i].zoning_size;
				me[i-1].job_name=' ';
				for(int j=i; j<me.size()-1; j++)
				{
					me[j].job_name=me[j+1].job_name;
					me[j].start_address=me[j+1].start_address;
					me[j].zoning_size=me[j+1].zoning_size;
					me[j].state=me[j+1].state;
				}
				me.pop_back();
			}
			else if(me[i+1].state==0)
			{
				me[i].zoning_size+=me[i+1].zoning_size;
				me[i].job_name=' ';
				me[i].state=0;
				for(int j=i+1; j<me.size()-1; j++)
				{
					me[j].job_name=me[j+1].job_name;
					me[j].start_address=me[j+1].start_address;
					me[j].zoning_size=me[j+1].zoning_size;
					me[j].state=me[j+1].state;
				}
				me.pop_back();
			}
			else
			{
				me[i].job_name=' ';
				me[i].state=0;
				cout<<"回收成功！！！"<<endl;
				break;
			}
		}
	}
}

void menu()
{
	cout<<"\n\n";
	cout<<"1. 分配内存"<<endl;
	cout<<"2. 回收内存"<<endl;
	cout<<"3. 显示内存使用情况"<<endl;
	cout<<"4. 退出"<<endl;
	cout<<"\n\n";
	cout<<"请输入选择:";
}

void print()   //显示内存使用情况
{

	cout<<"分区号\t作业名\t起始地址\t分区大小\t状态"<<endl;
	vector<memory>::iterator it;
	for(it=me.begin(); it!=me.end(); it++)
	{
		cout<<(*it).zoning_number<<"\t"<<(*it).job_name<<"\t"<<(*it).start_address<<"\t\t"<<(*it).zoning_size<<"\t\t"<<(*it).state<<endl;
	}
}

int main()
{
	//初始化头结点
	memory head;
	head.zoning_number=0;
	head.start_address=0;
	head.zoning_size=1024;
	head.state=0;

	me.push_back(head);

	int sel;
	int flag=1;
	while(1)
	{
		menu();
		cin>>sel;
		switch(sel)
		{
			case 1:
				FF();
				break;
			case 2:
				recovery();
				break;
			case 3:
				print();
				break;
			case 4:
				flag=0;
				break;
		}
		if(flag==0)
			break;
	}
}

运行效果：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
我最先用list写了一个，然后发现有bug，但是迭代器用太多啦，有点混乱，希望有迭代器用得好的大佬帮忙指正一下，互相交流（23333）

#include<bits/stdc++.h>
#include<iterator>
using namespace std;
#define SIZE 2

typedef struct Memory
{
	int zoning_number;//分区号
	char job_name;//作业名
	int start_address;//起始地址
	int zoning_size;//分区大小
	int state;//状态 （0 1）   1：已分配 2：未分配
} memory;

list<memory> me;

bool cmp(memory a,memory b)
{
	return a.start_address<b.start_address;
}

void FF()   //首次适应算法
{
	int flag=0;//分配成功 1  失败 0
	memory node;//申请新节点
	//input
	cout<<"作业名(一个字符):";
	char name;
	cin>>name;
	node.job_name=name;
	cout<<"作业占内存大小：";
	int u;
	cin>>u;
	node.zoning_size=u;
	//ff算法
	me.sort(cmp);//地址递增排序
	list<memory>::iterator it;
	for(it=me.begin(); it!=me.end(); it++)
	{
		if((*it).state==0)   //空闲分区链
		{
			if((*it).zoning_size>u)
			{
				if((*it).zoning_size-u<=2)
				{
					(*it).state=1;//将该分区从空闲链中移除
					(*it).job_name=name;
					flag=1;
					break;
				}
				else     //有空闲块能满足需求且有剩余
				{
					node.zoning_number=(*it).zoning_number;
					node.start_address=(*it).start_address;
					(*it).zoning_number+=1;
					(*it).start_address+=u;
					(*it).zoning_size-=u;
					node.state=1;
					me.insert(it--,node);
					flag=1;
					break;
				}
			}
		}
	}
	if(flag==1)
	{
		cout<<"分配成功！！！"<<endl;
	}
	else
		cout<<"分配失败！！！"<<endl;
}

void recovery()   //回收内存
{
	cout<<"输入要回收分区的作业名(一个字符):";
	char name;
	cin>>name;
	list<memory>::iterator it;
	list<memory>::iterator next_mem;
	list<memory>::iterator pre_mem;
	list<memory>::iterator tail;
	list<memory>::iterator now;
	list<memory>::iterator now1;
	list<memory>::iterator next_mem1;
	for(it=me.begin(); it!=me.end(); it++)
	{
		if((*it).job_name==name&&it==me.begin())//开头
		{
			pre_mem=it;
			next_mem=++it;//后一个分区
			cout<<(*next_mem).zoning_number<<endl;
			if((*next_mem).state==0)   //后一个分区为空闲   合并
			{
				(*pre_mem).zoning_size+=(*next_mem).zoning_size;//合并 回收区与f2
				(*pre_mem).state=0;
				(*pre_mem).job_name=' ';
				pre_mem=it;
				next_mem=++it;
				while(next_mem!=me.end())
				{
					(*pre_mem).job_name=(*next_mem).job_name;
					(*pre_mem).start_address=(*next_mem).start_address;
					(*pre_mem).zoning_size=(*next_mem).zoning_size;
					(*pre_mem).state=(*next_mem).state;
					pre_mem++;
					next_mem++;
				}//删除f2过程
				me.pop_back();
				cout<<"回收成功！！！"<<endl;
				break;
			}
			else
			{
				(*pre_mem).job_name=' ';
				(*pre_mem).state=0;
				cout<<"回收成功！！！"<<endl;
				break;
			}
		}
		tail=me.end();
		--tail;
		if((*it).job_name==name&&it==tail)//结尾
		{
			pre_mem=--it;//结尾的上一个元素
			if((*pre_mem).state==0)//合并
			{
				(*pre_mem).zoning_size+=(*tail).zoning_size;
				me.pop_back();
				cout<<"回收成功！！！"<<endl;
				break;
			}
		}
		//3种情况
		if((*it).job_name==name)
		{
			pre_mem=--it;
			now=++it;
			next_mem=++it;
			if((*pre_mem).state==0&&(*next_mem).state==0)//3个合并
			{
				(*pre_mem).zoning_size=(*now).zoning_size+(*next_mem).zoning_size+(*pre_mem).zoning_size;//合并大小

				now1=now;
				next_mem1=next_mem;

				while(next_mem1!=me.end())
				{
					(*now1).job_name=(*next_mem1).job_name;
					(*now1).start_address=(*next_mem1).start_address;
					(*now1).zoning_size=(*next_mem1).zoning_size;
					(*now1).state=(*next_mem1).state;
					now1++;
					next_mem1++;
				}//删
				me.pop_back();
				it=now; 
				while(next_mem!=me.end())
				{
					(*now).job_name=(*next_mem).job_name;
					(*now).start_address=(*next_mem).start_address;
					(*now).zoning_size=(*next_mem).zoning_size;
					(*now).state=(*next_mem).state;
					now++;
					next_mem++;
				}//删
				me.pop_back();
				cout<<"333回收成功！！！"<<endl;
				break;
			}
			else if((*pre_mem).state==0)
			{
				(*pre_mem).zoning_size+=(*now).zoning_size;
				while(next_mem!=me.end())
				{
					(*now).job_name=(*next_mem).job_name;
					(*now).start_address=(*next_mem).start_address;
					(*now).zoning_size=(*next_mem).zoning_size;
					(*now).state=(*next_mem).state;
					now++;
					next_mem++;
				}//删
				me.pop_back();
				cout<<"f1回收成功！！！"<<endl;
			}
			else if((*next_mem).state==0)
			{
				(*now).zoning_size+=(*next_mem).zoning_size;
				
				now1=next_mem;
				next_mem1=++next_mem;
				while(next_mem1!=me.end())
				{
					(*now1).job_name=(*next_mem1).job_name;
					(*now1).start_address=(*next_mem1).start_address;
					(*now1).zoning_size=(*next_mem1).zoning_size;
					(*now1).state=(*next_mem1).state;
					now1++;
					next_mem1++;
				}//删
				me.pop_back();
				cout<<"f2回收成功！！！"<<endl;
				break;
			}
			else//都不邻接
			{
				(*now).job_name=' ';
				(*now).state=0;
				cout<<"回收成功！！！"<<endl;
				break;
			}
		}
	}
}

void menu()
{
	cout<<"\n\n";
	cout<<"1. 分配内存"<<endl;
	cout<<"2. 回收内存"<<endl;
	cout<<"3. 显示内存使用情况"<<endl;
	cout<<"4. 退出"<<endl;
	cout<<"\n\n";
	cout<<"请输入选择:";
}

void print()   //显示内存使用情况
{

	cout<<"分区号\t作业名\t起始地址\t分区大小\t状态"<<endl;
	list<memory>::iterator it;
	for(it=me.begin(); it!=me.end(); it++)
	{
		cout<<(*it).zoning_number<<"\t"<<(*it).job_name<<"\t"<<(*it).start_address<<"\t\t"<<(*it).zoning_size<<"\t\t"<<(*it).state<<endl;
	}
}

int main()
{
	//初始化头结点
	memory head;
	head.zoning_number=0;
	head.start_address=0;
	head.zoning_size=1024;
	head.state=0;

	me.push_front(head);

	int sel;
	int flag=1;
	while(1)
	{
		menu();
		cin>>sel;
		switch(sel)
		{
			case 1:
				FF();
				break;
			case 2:
				recovery();
				break;
			case 3:
				print();
				break;
			case 4:
				flag=0;
				break;
		}
		if(flag==0)
			break;
	}
}
顾道长生'
关注
专栏目录
计算机操作系统——动态分区分配算法模拟（C#）
明宇逸风的博客
07-30 6958
动态分区分配算法的模拟四类算法首次适应算法(FF)循环首次适应算法(NF)最佳适应算法(BF)最坏适应算法(WF)四类算法流程图首次适应算法(FF)循环首次适应算法(NF)最佳适应算法(BF)最坏适应算法(WF)源代码类代码Partiton.csProgram.csSetting.csWay.csWork.cs算法截图主函数截图 四类算法 首次适应算法(FF) 在首次适应算法中，是从已建立好的数组中顺序查找，直至找到第-一个大小能满足要求的空闲分区为止，然后再按照作业大小，从该分区中划出一块内存空间分配给请
操作系统_存储管理动态分区分配及回收算法_附源码运行截图_C++
m0_61714058的博客
05-16 1561
一、目的和要求 分区管理是应用较广泛的一种存储管理技术。本实验要求用一种结构化高级语言构造分区描述器，编制动态分区分配算法和回收算法模拟程序，并讨论不同分配算法的特点。 二、实验内容 1、编写：First Fit Algorithm 2、编写：Best Fit Algorithm 3、编写：空闲区回收算法 三、提示和说明 （一）主程序 1、定义分区描述器node，包括 3个元素： （1）adr——分区首地址 （2）size——分区大...
使用动态分区分配方式的模拟
jiashaoniubi的博客
12-16 1442
使用动态分区分配方式的模拟 1、实验目的 了解动态分区分配方式中使用的数据结构和分配算法，并进一步加深对动态分区 存储管理方式及其实现过程的理解。 2、实验内容 （1）用 C 语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程 alloc( )和回收过程 free( )。其中，空闲分区通过空闲分区链来管理：在进行内存 分配时，系统优先使用空闲区低端的空间。 （2）假设初始状态下，可用的内存空间为 640KB，并有下列的请求序列： •作业 1 申请 130KB。 •作业 2 申请 60KB。 •作业
操作系统实验三（动态分区分配算法）
蒟蒻达的博客
12-07 9318
动态分区分配算法 一、实验目的 用高级语言编写和调试一个内存连续分配中动态分区分配模拟程序，以加深对进程的概念及进程调度算法的理解． 二、实验指导 设计程序模拟内存动态分区分配流程，要求实现三项功能：分配内存、回收内存、显示内存使用情况 内存连续分配动态分区分配流程图如下 回收分区时应考虑分区合并的情况，三种情况，如下图 #include<bits/stdc++.h> using ...
实验二 实现动态分区分配模拟程序
12-31
实验内容： 编写一个动态分区分配算法模拟程序，加深对动态分区存储管理方式及其实现过程的理解。 要求： 1.空闲分区通过空闲区链进行管理，在内存分配时，优先考虑低地址部分的空闲区。 2.分别采用首次适应算法、最佳适应算法和最坏适应算法模拟内存空间的动态分配与回收，每次分配和回收后显示出空闲区链的详细情况（说明：在申请不成功时，需要打印当前内存的占用情况信息）。 3.进程对内存空间的申请和释放可由用户自定义输入。 4.参考请求序列如下： (1) 初始状态下可用内存空间为640KB； (2) 进程1申请130KB； (3) 进程2申请60KB； (4) 进程3申请100K
操作系统：动态分区分配算法
热门推荐
但行好事 莫问前程
12-11 2万+
目的：陆续整理近一年的学习收获                                                        动态分区分配算法 一：概念  动态分区分配是根据进程的实际需要，动态地为之分配内存空间。在实现可变分区分配时，将涉及到分区分配中所用的数据结构、分区分配算法和分区的分配与回收操作这样三个问题。    首次适应算法（First Fit）：   算法...
操作系统---动态分区分配算法
Swift_Jane的博客
08-22 588
可变分区分配算法中，当有新作业请求分配内存时所采用的存储分配算法有以下四种！
操作系统——实验五 动态分区分配算法的模拟
08-05
用C/C++实现一个完整的（可变）动态分区管理器，包括分配，回收，分区碎片整理等。希望同学们实现如下功能： 初始化功能：内存状态设置为初始状态。 分配功能：要求至少使用两种算法，用户可以选择使用。 回收...
操作系统实验三——动态分区分配方式的模拟
08-29
通过这个实验，学生不仅可以掌握C++编程技巧，还能深入理解操作系统中存储器管理的基本原理和实现方法，尤其是动态分区分配的策略。这对于后续学习操作系统、系统编程以及优化内存管理策略等方面的知识具有重要意义...
操作系统-动态分区分配算法代码
最新发布
05-20
实现对存储器动态分区分配算法的认识。掌握首次适应算法、循环适应算法、最坏适应算法、最佳适应算法的内存分配过程。掌握内存回收的策略。 1、首次适应算法（First Fit） 将空闲分区链以地址递增的顺序连接；在进行...
计算机操作系统实验报告_动态分区分配方式的模拟
12-04
一是用C 语言实现对采用首次适应算法和最佳适应算法的动态分区分配过程ALLOC（）和回收过程FREE（），其中空闲分区由空闲分区链来管理，进行分配时，系统优先使用空闲区底端空间。 二是假设初始状态下，可用内存空间为640KB。按照题目要求的作业顺序，以及各个作业分配和回收的内存空间。分别采用首次适应法和最佳适应法，对内存进行分配和回收，要求每次分配和回收后显示空闲内存分区链的情况。
动态分区分配算法
06-22
《计算机与操作系统（第四版）》动态分区分配算法 1.首次适应算法（first fit） 2.循环首次适应算法（next fit） 3.最佳适应算法（best fit）
用C++编写和调试多道环境下连续可变式内存分配的模拟程序
06-03
1、实验目的 用高级语言编写和调试多道环境下连续可变式内存分配的模拟程序，以加深对连续可变式内存分配算法的理解。 2、实验内容 编写并调试一个连续可变式内存分配模拟程序。 采用链表来管理连续的内存分区，在进程随意创建和撤销的情况下，对空闲分区进程进行分配和合并。 系统中的进程信息可以采用连续表或PCB链的方式来模拟。
计算机操作系统实验_动态分区分配方式模拟
12-01
1、代码完整，注释很详细，复制到... 测试用例格式如下： 输入： 动态分区分配算法选择 可用内存空间容量 序号/进程号/申请或释放操作/申请或释放的容量 其中： (1 ) 动态分区分配算法：1----首次适应，2----最佳适应。
操作系统内存动态分区分配算法（Java实现）
weixin_34295316的博客
01-12 1万+
一. 内存的作用 内存是计算机的一个重要组成部分，它的主要作用在于配合 CPU 的高速运转，使得计算机的运行速度得到大大地提升 我们应该知道，计算机上的一切都是程序，我们使用计算机其实就是在运行计算机上的各种程序，而这些程序都存储在我们的硬盘中（外存），硬盘中的数据内容是几乎可以永久存储的但是 它的读取速度相较于 CPU 的处理速度...
动态分区分配方式 java_使用动态分区分配方式的模拟
weixin_36047753的博客
02-19 393
packagememory;importjava.util.ArrayList;importjava.util.Collection;importjava.util.Scanner;public classMain {static ArrayList list = new ArrayList(); //建立一个链表，来表示内存的使用情况static Scanner sc = newScann...
操作系统实验：内存动态分区分配算法实现
"该文档是关于操作系统实验报告的，主要关注内存分配算法，特别是连续分配技术中的动态分区方法。实验涵盖了首次适应、循环首次适应、最佳适应和最差适应这四种算法的实现，并通过VSCode进行模拟。实验要求设计和...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

顾道长生'

您的支持是我创作的动力

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

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

打赏作者

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

抵扣说明：

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

余额充值