内存管理（C++实训题）

写在前面：仅为个人代码/总结，未必标准，仅供参考！如有错误，还望指出交流，共同进步！

内存管理

【问题描述】
离第一个操作系统HNU-OS发布已经没有多少时间了，但它的一些组件还没有完成，内存管理器就是其中之一。根据开发人员的计划，在第一个版本中，内存管理器将非常简单和直观。它将支持三个操作：

alloc n —— 分配n个字节内存，返回已分配块的正整数标识符x(x初始值为0，每次分配增长1)

erase x —— 删除标识符x所在的块

defragment —— 整理空余内存碎片，将所有块尽量靠近内存的开始位置，并保持各自的顺序

在此情况下，内存模型非常简单，它是一个m字节的序列，为了方便起见，从第一个字节到第m字节进行编号。

第一个操作alloc n有一个参数n，表示被分配的内存块大小。在处理此操作时，内存中将分配n个连续字节的空闲块。 如果这些块的数量超过一个，则优先选择最接近内存开始(即第一个字节)的块。 所有这些字节都被标记为非空闲，内存管理器返回一个32位整数数字令牌，代表该块的标识符。 如果不可能分配这样大小的空闲块，则返回NULL。

第二个操作erase x以x为参数，表示某个块的标识符。此操作释放系统内存，将此块的字节标记为空闲以供进一步使用。 如果此标识符没有指向先前分配的块(该块尚未被释放)，则返回ILLEGAL_ERASE_ARGUMENT。

最后一个操作defragment没有任何参数，只会使占用的内存部分更接近内存的开始，而不会更改它们各自的顺序。

在当前的实现中，将使用从1开始的连续整数作为标识符。每个成功的alloc操作过程都应该返回接下来的编号。不成功的alloc操作不影响计数。

编写内存管理器的实现，为每个alloc命令输出返回的值，为所有失败的erase命令输出ILLEGAL_ERASE_ARGUMENT。

【输入形式】
输入数据的第一行包含两个正整数t和m（1<=t<=500, 1<=m<=105)，其中t表示需要内存管理器来处理的操作个数，m表示有效的内存字节大小。接下来的t行每一行代表一个操作。

【输出形式】
输出有多行，每行或者是alloc操作的结果，或者是失败的erase操作的结果ILLEGAL_ERASE_ARGUMENT。其顺序与输入的操作次序一致。

【样例输入】

6 10
alloc 5
alloc 3
erase 1
alloc 6
defragment
alloc 6

【样例输出】

1
2
NULL
3

【示例代码】

#include <bits/stdc++.h>
using namespace std;
struct Piece
{
    int num;
    int length;
    bool cur;
};
int main()
{
    int t,m;
    cin>>t>>m;
    vector <Piece> P;
    Piece temp;
    int yu=m,coun=0;
    for(int i=1;i<=t;i++)
    {
        string s;
        int n;
        cin>>s;
        if(s!="defragment") {cin>>n;}
        if(s=="alloc")
        {
            int len=P.size();
            bool flag=false;
            if(len!=0)
            {
                for(int j=0;j<len;j++)
                {
                    if(P[j].cur==false&&P[j].length>=n)//若能，则将新数据插入到最前面的那块已释放内存
                    {
                        coun++;
                        cout<<coun<<endl;
                        temp.cur=true;
                        temp.length=n;
                        temp.num=coun;
                        P[j].length-=n;
                        if(P[j].length==0)
                        {
                            vector<Piece>::iterator it=P.begin()+j;
                            P.erase(it);
                        }
                        P.insert(P.begin()+j,temp);

                        flag=true;
                        break;
                    }
                }
            }
            if(flag==false)
            {
                 if(yu>=n)//若插不进前面的已释放内存块，则判断有效内存末端是否有足够内存
                {
                    coun++;
                    cout<<coun<<endl;
                    yu-=n;
                    temp.length=n;
                    temp.num=coun;
                    temp.cur=true;
                    P.push_back(temp);
                }
                else//没有则操作失败
                {
                    cout<<"NULL"<<endl;
                }
            }

        }
        else if(s=="erase")
        {
            int len=P.size();
            bool b=false;
            for(int i=0;i<len;i++)
            {
                if(n==P[i].num)
                {
                    if(P[i].cur==false)//已释放的不能再释放一次
                    {
                        break;
                    }
                    P[i].cur=false;//未重新整理容器前将释放的内存状态标为false
                    b=true;
                    break;
                }
            }
            if(b==false)
            {
                cout<<"ILLEGAL_ERASE_ARGUMENT"<<endl;
            }
        }
        else if(s=="defragment")//将状态为false的内存空间整理到有效内存末端
        {
            int len=P.size();
            for(int j=0;j<len;j++)
            {
                if(P[j].cur==false)
                {
                    vector<Piece>::iterator it=P.begin()+j;
                    P.erase(it);
                }
            }
            len=P.size();
            yu=m;
            for(int j=0;j<len;j++)
            {
                yu-=P[j].length;
            }
        }
    }
    return 0;
}