MFC实现操作系统四种内存分配算法的模拟

作为操作系统的期末作业，和大家分享一下操作系统内存分配算法基于MFC的可视化模拟，本人小菜鸟一只，欢迎大神指正，以后也希望能坚持下来写技术博客的习惯，不断总结不断积累，结交更多兴趣爱好相同的朋友和前辈。

-----------------------------------  正文----------------------------

内存分配算法是操作系统白皮第四版中第五章节的内容，其中介绍了四种内存分配算法分别是

1.首次适应算法  

优点：速度快

缺点：内存利用不均衡，总是从低地址寻找

2.循环首次适应算法

优点：速度快，内存利用均衡

3.最佳适应算法

特点：按空间从小到大排序，特别容易产生碎片。

4.最差适应算法

特点：按空间从大到小排序，避免产生碎片，但不适合大的作业。

其中首次最佳适应算法指的是操作系统在内存分配的时候将申请分配的内存大小分别和内存块中的空间连续比较，线性找到第一个符合申请内存大小的空间立即分配。循环首次是在首次适应算法的基础上标记上一次分配内存的位置，在下一次分配时直接从上次分配的地址开始遍历。最佳与最差适应算法相对应，分别都是遍历了所有内存空间后比较已有空闲内存块大小和申请分配内存块大小进行比较，做差相差最小或最大的即为最佳和最差适应算法。四种算法各有利弊。

------------------------------编程实现-------------------------

核心思想是利用链表将每行的内容存储到链表，然后将每块空间的属性封装成一个结构体，根据每个节点不同的状态进行内存的分配与回收。效果如下

核心代码

bool CSortNode::FirstSort(int nSize)//首次适应算法
{
	Node* temp = m_pHead;
	while (temp)
	{
		if (temp->m_nState == NOTSPAEATED)
		{
			if (nSize <= temp->m_nSize)
			{
				Node *p = new Node;//设置新节点的属性
				p->m_nAddress = temp->m_nAddress;
				p->m_nSize = nSize;
				p->m_nState = HAVESPARATED;
				
				if (temp->pPro ==  NULL)  //新节点的添加
				{
					p->pPro = NULL;
					p->pNext = temp;
					temp->pPro = p;

					p->m_nAddress = m_pHead->m_nAddress;
					p->m_nSize = nSize;
					p->m_nState = HAVESPARATED;
					p->m_nPosition = 1;//记录位置以便最佳算法
					m_pHead = p;
					
				}
				else
				{
					temp->pPro->pNext = p;
					p->pNext = temp;
					p->pPro = temp->pPro;
					temp->pPro = p;
				}
				m_pLoopPos = p;//记录第一次申请的位置，方便loop算法计算下一次
				
				temp->m_nSize -= nSize;
				temp->m_nAddress += nSize;
				return true;
			}
		}
		
		temp = temp->pNext;
	}
	return false;
}

void CSortNode::CreateReceive()
{
	Node *temp = m_pHead;

	while (temp)
	{
	
		if (temp->pNext == NULL)
		{
			m_pEnd = temp;
			return ;
		}
		else if (temp->pNext->pNext == NULL)
		{
			if (temp->m_nState == temp->pNext->m_nState && temp->m_nState == NOTSPAEATED || temp->pNext->m_nSize == 0)
			{

				temp->m_nSize += temp->pNext->m_nSize;
				Node *del = temp->pNext;
				temp->pNext = temp->pNext->pNext;//只要有两段相邻空闲区域就合并
				delete del;
				del = NULL;
				m_pEnd = temp;
			}

			return ;

		}
		if (temp->m_nState == temp->pNext->m_nState && temp->m_nState == NOTSPAEATED || temp->pNext->m_nSize == 0)
		{
			
			temp->m_nSize += temp->pNext->m_nSize;
			Node *del = temp->pNext;
			temp->pNext = temp->pNext->pNext;//只要有两段相邻空闲区域就合并
			delete del;
			del = NULL;
			
			continue;//精妙之笔
			
		}
		
		temp = temp->pNext;
	}
	
	return ;
}

bool CSortNode::BadSort(int nSize)
{
	Node *maxPos = NULL;
	int max = 0;
	Node* temp = m_pHead;
	while (temp)
	{
		if (temp->m_nState == NOTSPAEATED)
		{
			if (nSize <= temp->m_nSize)
			{
				if (max <= temp->m_nSize - nSize)
				{
					max = temp->m_nSize - nSize;
					maxPos = temp;//记录最小结点位置

				}
			}
		}

		temp = temp->pNext;
	}

	if (!maxPos)
	{
		return false;
	}
	Node *p = new Node;//设置新节点的属性
	p->m_nAddress = maxPos->m_nAddress;
	p->m_nSize = nSize;
	p->m_nState = HAVESPARATED;

	if (maxPos->pPro == NULL)  //新节点的添加
	{
		p->pPro = NULL;
		p->pNext = maxPos;
		maxPos->pPro = p;

		p->m_nAddress = m_pHead->m_nAddress;
		p->m_nSize = nSize;
		p->m_nState = HAVESPARATED;
		p->m_nPosition = 1;//记录位置以便最佳算法
		m_pHead = p;

	}
	else
	{
		maxPos->pPro->pNext = p;
		p->pNext = maxPos;
		p->pPro = maxPos->pPro;
		maxPos->pPro = p;
	}
	maxPos->m_nSize -= nSize;
	maxPos->m_nAddress += nSize;
	return true;
}