操作系统 内存分配与回收算法 模拟

#include <iostream>

#include <string>
using namespace std;
const int minsize=3;//最小不能再分隔大小为3
struct Node
{
string name;
int s_address;
int size;
Node *link;
};
class CLink
{
public:
CLink();//构造函数
~CLink();//析构函数
const CLink &operator =(const CLink& l);//重载赋值操作符
void insertNode(string &na,int& s_a,int& si);//插入新元素（si由小到大）到链表合适的位置
bool isEmpty();//判断是否为空
int length();//求出链表长度
void destroy();//销毁
void print();//打印出元素
void first_fit(int& si);//首次适应
void best_fit(int& si);//最佳适应
void worst_fit(int& si);//最坏适应
void quik_fit(int& si);//快速适应
void next_fit(int& si);//
void retrieve(string& na,int& s_a,int& si);//回收内存
void sortbyaddress();//按照地址由小到大排序
void sortbysize();//按照区块大小由小到大排序
void sortbysized();//按照区块大小降序排序
protected:
Node *first;
Node *last;

};
CLink::CLink()
{//构造函数
first=NULL;
last=NULL;
}
CLink::~CLink()
{
Node *temp;
while(first!=NULL)
{
temp=first;
first=first->link;
delete temp;
}
last=NULL;

}
void CLink::insertNode(string &na,int& s_a,int& si)
{//按照大小由小到大排序
Node *Current;
Node *trailCurrent;//指向Current的前一个节点
Node *newNode;
bool found;

newNode = new Node;//建立一个新节点

newNode->name=na;
newNode->s_address=s_a;
newNode->size=si;
newNode->link=NULL;//

if(first==NULL)//如果第一个节点为空（如果是第一次插入元素）
first=newNode;//将新节点赋给第一个节点
else
{//如果不是第一次
Current =first;
found = false;
while(Current!=NULL && !found)
{
if(Current->size >= si)
found = true;
else
{
trailCurrent = Current;
Current = Current->link;
}

}
if(Current==first)
{
newNode->link = first;
first = newNode;

}
else
{
trailCurrent->link = newNode;
newNode->link = Current;
}
}

}
void CLink::print()
{
Node *Current;
Current = first->link;//头节点赋给当前节点

while(Current!=NULL)//当前节点不为空，一直向后遍历打印
{
cout<<Current->name<<"/t";
cout<<Current->s_address<<"/t";
cout<<Current->size<<"/n";
Current = Current->link;
}

}
bool CLink::isEmpty()//判断是否为空
{
return (first==NULL);//如果第一个节点为空，返回值
}
void CLink::destroy()
{
Node *temp;//定义一个临时指针变量
while(first!=NULL)
{
temp=first;
first=first->link;
delete temp;
}
last=NULL;
}
const CLink& CLink::operator=(const CLink& l)
{
Node *newNode;
Node *Current;
if(this!=&l)//避免自己给自己赋值
{
if(first!=NULL)//如果链表不为空
destroy();
if(l.first==NULL)
{//如果要拷贝的对象为空
this->first = NULL;
this->last = NULL;
}
else
{
Current = l.first;
first= new Node;
first->name=Current->name;//
first->s_address=Current->s_address;
first->size=Current->size;
first->link =NULL;

last =first;
Current = Current->link;
while(Current!=NULL)
{
newNode = new Node;
newNode->name=Current->name;
newNode->s_address=Current->s_address;
newNode->size=Current->size;
newNode->link=NULL;
last->link=newNode;
last=newNode;
Current = Current->link;
}
}
}
return *this;
}
void CLink::sortbyaddress()
{//按照地址升序排列
string sname;
int s_a;
int si;
Node *Current;//指向当前节点
Node *trailCurrent;//指向当前节点的前一个节点
for(trailCurrent=first->link;trailCurrent!=NULL;trailCurrent=trailCurrent->link)//控制条件有问题
{
for(Current=trailCurrent->link;Current!=NULL;Current=Current->link)//控制条件有问题
{
if(trailCurrent->s_address > Current->s_address)
{

sname=trailCurrent->name;
s_a=trailCurrent->s_address;
si=trailCurrent->size;

trailCurrent->name=Current->name;
trailCurrent->s_address=Current->s_address;
trailCurrent->size=Current->size;

Current->name=sname;
Current->s_address=s_a;
Current->size=si;

}
}
}
}
void CLink::sortbysize()
{//按照区块大小升序排列
string sname;
int s_a;
int si;
Node *Current;//指向当前节点
Node *trailCurrent;//指向当前节点的前一个节点
for(trailCurrent=first->link;trailCurrent!=NULL;trailCurrent=trailCurrent->link)//控制条件有问题
{
for(Current=trailCurrent->link;Current!=NULL;Current=Current->link)//控制条件有问题
{
if(trailCurrent->size > Current->size)
{

sname=trailCurrent->name;
s_a=trailCurrent->s_address;
si=trailCurrent->size;

trailCurrent->name=Current->name;
trailCurrent->s_address=Current->s_address;
trailCurrent->size=Current->size;

Current->name=sname;
Current->s_address=s_a;
Current->size=si;

}
}
}
}
void CLink::sortbysized()
{//按照区块大小降序排列
string sname;
int s_a;
int si;
Node *Current;//指向当前节点
Node *trailCurrent;//指向当前节点的前一个节点
for(trailCurrent=first->link;trailCurrent!=NULL;trailCurrent=trailCurrent->link)//控制条件有问题
{
for(Current=trailCurrent->link;Current!=NULL;Current=Current->link)//控制条件有问题
{
if(trailCurrent->size < Current->size)
{

sname=trailCurrent->name;
s_a=trailCurrent->s_address;
si=trailCurrent->size;

trailCurrent->name=Current->name;
trailCurrent->s_address=Current->s_address;
trailCurrent->size=Current->size;

Current->name=sname;
Current->s_address=s_a;
Current->size=si;

}
}
}
}
void retrieve(string& na,int& s_a,int& si)
{
Node *trailCurrent;
Node *Current;
Current = trailCurrent->link;
if(trailCurrent->s_address+trailCurrent->size+1 == s_a)
trailCurrent->size = trailCurrent->size+si;
else if(s_a+si+1 == Current->s_address)
{
Current->s_address = s_a;
Current->size = Current->size+si;
}
else if(trailCurrent->s_address+trailCurrent->size+1 == s_a && s_a+si+1 == Current->s_address)
{
trailCurrent->size = trailCurrent->size+si+Current->size;
//删除Current所指向的节点；
}
else if(!(trailCurrent->s_address+trailCurrent->size+1 == s_a) && !(s_a+si+1 == Current->s_address))
{
//将s_a，si作为新的节点插入到空闲分区表
}

}
void CLink::first_fit(int& si)
{//按照地址从低到高，依次向后查找，找到第一个适合的停止
//如果到了表尾好没有找到，那么无法分配
sortbyaddress();//按照地址递增排序
Node *Current;
bool flag=false;
Current = first->link;//头节点赋给当前节点
while(Current!=NULL)
{
if(Current->size >= si+minsize)
{
Current->s_address=Current->s_address+si;
Current->size=Current->size-si;
flag = true;
return;
}
else
{
Current=Current->link;
}

}
if(!flag)
cout<<"没有合适的内存区块！/n";

}
void CLink::best_fit(int& si)
{//内存区块从小到大排序，然后从头找，找到第一个适合的就结束
//如果到了表尾还没找到，那么无法分配！
Node *Current;
bool flag=false;
Current = first->link;//头节点赋给当前节点
while(Current!=NULL)
{
if(Current->size >= si+minsize)
{
Current->s_address=Current->s_address+si;
Current->size=Current->size-si;
flag = true;
return;
}
else
{
Current=Current->link;
}

}
if(!flag)
cout<<"没有合适的内存区块！/n";
}
void CLink::quik_fit(int& si)
{//分类搜索法
//bool flag=false;
CLink la,lb,lc;
Node *Current;
Current=first->link;
/* while(Current!=NULL)
{//首先将区块按照大小分类
if(Current->size >= 1 && Current->size <= 10)
{
la.insertNode(Current->name,Current->s_address,Current->size);
}
if(Current->size >=11 && Current->size <= 100)
{
lb.insertNode(Current->name,Current->s_address,Current->size);
}
if(Current->size >=101 && Current->size <= 1000)
{
lc.insertNode(Current->name,Current->s_address,Current->size);
}
Current=Current->link;
}*/
//按照请求的大小进入不同的链表分配
//if(si>=1 && si<= 10)
//{
// la.best_fit(si);
//}
//if(si>= 11 && si<= 100)
//{
// lb.best_fit(si);
//}
//if(si>= 101 && si<=1000)
//{
// lc.best_fit(si);
//}
la.print();
lb.print();
lc.print();
}
void CLink::worst_fit(int& si)
{//挑一个最大的区块分给作业
//首先按照区块大小，由大到小排序，从头找，如果第一个适合，那么结束
//排序后第一个就是最大的区块，如果第一个适合，则分配
//否则，就不能分配
sortbysized();//降序排序
Node *Current;
bool flag=false;
Current = first->link;//头节点赋给当前节点
if(Current->size >= si+minsize)
{
Current->s_address=Current->s_address+si;
Current->size=Current->size-si;
flag = true;
return;
}

if(!flag)
cout<<"没有合适的内存区块！/n";

}
void CLink::next_fit(int& si)
{
bool flag=false;
}
int main()
{
CLink l0,l1,l2,l3,l4,l5;

int s_a,si;
string na;
int judge=1;//控制退出程序
int choice;//控制选择操作
while(judge)
{
cout<<"********************************************************/n";
cout<<"****** 说明：本程序适用作业内存分配 ******/n";
cout<<"******** 请选择您的操作 *********/n";
cout<<"*********输入相应的数字，按下（Enter）键！ ************/n";
cout<<"************* 6.录入内存信息 ************/n";
cout<<"************* 1.首次适应 ************/n";
cout<<"************* 2.最佳适应 ************/n";
cout<<"************* 3.最坏适应 ************/n";
cout<<"************* 4.快速适应 ************/n";
cout<<"************* 5.循环首次适应 ************/n";
cout<<"************* 7.回收内存 ************/n";
cout<<"************* 0.退出程序 ************/n";
cout<<"********************************************************/n";

cin>>choice;
switch(choice)
{
case 0:
judge=0;
break;
case 6:
cout<<"请输入信息以“end”结束输入！/n";
cout<<"区块名 起始地址 区块大小"<<endl;
while(na.compare("end"))//如果相等则会返回0
{
l0.insertNode(na,s_a,si);
cin>>na>>s_a>>si;
}
cout<<"录入成功!/n";
//cout<<"请选择你使用的算法：/n";
//cout<<"区块名 起始地址 区块大小"<<endl;

//l0.print();
//cout<<p0.length();
break;
case 1:

l1=l0;//拷贝一份
if(l1.isEmpty())
{
cout<<"请先录入信息/n";
break;
}
else
{
int s1;
//cout<<"区块名 起始地址 区块大小"<<endl;

//l1.print();
cout<<"请输入要分配的空间的大小：/n";
cin>>s1;
cout<<"当前空闲分区为：/n";
cout<<"区块名 起始地址 区块大小/n";
l1.first_fit(s1);
l1.print();
break;
}
case 2:
l2=l0;//拷贝一份
if(l2.isEmpty())
{
cout<<"请先录入信息/n";
break;
}
else
{
int s2;
//cout<<"区块名 起始地址 区块大小"<<endl;

//l2.print();
cout<<"请输入要分配的空间的大小：/n";
cin>>s2;
cout<<"当前空闲分区为：/n";
cout<<"区块名 起始地址 区块大小/n";
l2.best_fit(s2);
l2.print();
break;
}
case 3:

l3=l0;//拷贝一份
if(l3.isEmpty())
{
cout<<"请先录入信息/n";
break;
}
else
{
int s3;
//cout<<"区块名 起始地址 区块大小"<<endl;

//l3.print();
cout<<"请输入要分配的空间的大小：/n";
cin>>s3;
cout<<"当前空闲分区为：/n";
cout<<"区块名 起始地址 区块大小/n";
l3.worst_fit(s3);
l3.print();
break;
}

case 4:
l4=l0;//拷贝一份
if(l4.isEmpty())
{
cout<<"请先录入信息/n";
break;
}
else
{
int s4;
//cout<<"区块名 起始地址 区块大小"<<endl;

//l4.print();
cout<<"请输入要分配的空间的大小：/n";
cin>>s4;
cout<<"当前空闲分区为：/n";
cout<<"区块名 起始地址 区块大小/n";
l4.quik_fit(s4);
//l4.print();
break;
}
case 5:
l5=l0;//拷贝一份
if(l5.isEmpty())
{
cout<<"请先录入信息/n";
break;
}
else
{
int s4;
//cout<<"区块名 起始地址 区块大小"<<endl;

//l5.print();
cout<<"请输入要分配的空间的大小：/n";
cin>>s4;
cout<<"当前空闲分区为：/n";
cout<<"区块名 起始地址 区块大小/n";
l5.quik_fit(s4);
l5.print();
break;
}
case 7:
//录入信息，na,s_a,si
retrieve(na,s_a,si);
break;
default:
cout<<"请选择目录中的选项！/n";
break;
}
}
return 0;
}
未完待续！
粗枝大叶仅供参考！