动态分区分配算法模拟的文档读写操作

Question

动态分区分配算法模拟，在此代码的基础上，如何实现将申请内存和释放内存的序列存放在文本文件中，还可以读取文档执行的代码。

int Init()//初始化内存状态设置（空闲分区的设置） 
{
    int Free_num; //空闲分区的个数 
    block_first = (LinkList)malloc(sizeof(LinkNode));
    block_last = (LinkList)malloc(sizeof(LinkNode));
    block_first->prior = NULL;
    block_first->next = block_last;
    cout << "请输入空闲分区数目：";
    cin >> Free_num;
    int Size[100];
    printf("\n请分别输入这%d空闲分区大小（单位KB）：\n", Free_num);
    for (int i = 0; i < Free_num; i++)
    {
        cin >> Size[i];
        if (Size[i] <= Min_Size) 
        {
            i--;
            cout << "\n输入错误，请重输！\n";
        }
        int temp = 0;
        temp = temp + Size[i];
        if (temp >= MAX_length) 
        {
            i--;
            cout << "\n输入错误，请重输！\n";
        }
    }
    LinkList p = block_first;
    for (int i = 0; i < Free_num; i++)
    {
        LinkList temp = (LinkList)malloc(sizeof(LinkNode));
        temp->data.size = Size[i];
        temp->data.state = Free;
        if (p == block_first)
            temp->data.address = 0;
        else
            temp->data.address = p->data.address + p->data.size;
        temp->prior = p;
        p->next = temp;
        p = p->next;

    }
    block_last = p;
    block_last->next = NULL;
    pn = block_first->next;
    return OK;
}
//最佳
int myMalloc1()//分配主存
{
    int request = 0;
    cout << "请输入需要分配的主存大小(单位:KB)：" << endl;
    cin >> request;
    if (request < 0 || request == 0)
    {
        cout << "分配大小不合适，请重试！" << endl;
        return ERROR;
    }
    if (Best_fit(request) == OK)
        cout << "分配成功！" << endl;
    else 
        cout << "内存不足，分配失败！" << endl;
    return OK;
}
//首次
int myMalloc2()//分配主存
{
    int request = 0;
    cout << "请输入需要分配的主存大小(单位:KB)：" << endl;
    cin >> request;
    if (request < 0 || request == 0)
    {
        cout << "分配大小不合适，请重试！" << endl;
        return ERROR;
    }

    if (First_fit(request) == OK) 
        cout << "分配成功！" << endl;
    else 
        cout << "内存不足，分配失败！" << endl;
    return OK;
}
//循环首次
int myMalloc3()//分配主存
{
    int request = 0;
    cout << "请输入需要分配的主存大小(单位:KB)：" << endl;
    cin >> request;
    if (request < 0 || request == 0)
    {
        cout << "分配大小不合适，请重试！" << endl;
        return ERROR;
    }
    if (Next_fit(request) == OK) 
        cout << "分配成功！" << endl;
    else 
        cout << "内存不足，分配失败！" << endl;
    return OK;
}
//最坏
int myMalloc4()//分配主存
{
    int request = 0;
    cout << "请输入需要分配的主存大小(单位:KB)：" << endl;
    cin >> request;
    if (request < 0 || request == 0)
    {
        cout << "分配大小不合适，请重试！" << endl;
        return ERROR;
    }

    if (Worst_fit(request) == OK) 
        cout << "分配成功！" << endl;
    else 
        cout << "内存不足，分配失败！" << endl;
    return OK;
}

int First_fit(int request)//首次适应算法
{
    //为申请作业开辟新空间且初始化
    LinkList temp = (LinkList)malloc(sizeof(LinkNode));
    temp->data.size = request;
    temp->data.state = Busy;
    cout << "请输入作业名：";
    cin >> temp->data.name;
    cout << endl;
    LinkNode* p = block_first->next;
    while (p)
    {
        if (p->data.state == Free && p->data.size - request <= Min_Size && p->data.size - request >= 0) //有大小恰好合适的空闲块
        {
            p->data.state = Busy;
            for (int i = 0; i < 10; i++) 
            {
                p->data.name[i] = temp->data.name[i];
            }
            return OK;
            break;
        }
        if (p->data.state == Free && p->data.size - request > Min_Size) //有空闲块能满足需求且有剩余
        {
            temp->prior = p->prior;
            temp->next = p;
            temp->data.address = p->data.address;
            p->prior->next = temp;
            p->prior = temp;
            p->data.address = temp->data.address + temp->data.size;
            p->data.size -= request;
            return OK;
            break;
        }
        p = p->next;
    }
    return ERROR;
}



int Best_fit(int request)//最佳适应算法
{
    int ch; //记录最小剩余空间
    LinkList temp = (LinkList)malloc(sizeof(LinkNode));
    temp->data.size = request;
    temp->data.state = Busy;
    LinkNode* p = block_first->next;
    LinkNode* q = NULL; //记录最佳插入位置
    cout << "请输入作业名：";
    cin >> temp->data.name;
    while (p) //初始化最小空间和最佳位置
    {
        if (p->data.state == Free && (p->data.size >= request))
        {
            if (q == NULL)
            {
                q = p;
                ch = p->data.size - request;
            }
            else if (q->data.size > p->data.size)
            {
                q = p;
                ch = p->data.size - request;
            }
        }
        p = p->next;
    }

    if (q == NULL) return ERROR;//没有找到空闲块
    else if (q->data.size - request <= Min_Size)
    {
        q->data.state = Busy;
        for (int i = 0; i < 10; i++) 
        {
            q->data.name[i] = temp->data.name[i];
        }
        return OK;
    }
    else
    {
        temp->prior = q->prior;
        temp->next = q;
        temp->data.address = q->data.address;
        q->prior->next = temp;
        q->prior = temp;
        q->data.address += request;
        q->data.size = ch;
        return OK;
    }
    return OK;
}

int Worst_fit(int request)//最坏适应算法
{
    int max; //记录最大剩余空间
    LinkList temp = (LinkList)malloc(sizeof(LinkNode));
    temp->data.size = request;
    temp->data.state = Busy;
    LinkNode* p = block_first->next;
    LinkNode* q = NULL; //记录最佳插入位置
    cout << "请输入作业名：";
    cin >> temp->data.name;
    while (p) //初始化最大空间和最佳位置
    {
        if (p->data.state == Free && (p->data.size >= request))
        {
            if (q == NULL)
            {
                q = p;
                max = p->data.size - request;
            }
            else if (q->data.size < p->data.size)
            {
                q = p;
                max = p->data.size - request;
            }
        }
        p = p->next;
    }

    if (q == NULL) return ERROR;//没有找到空闲块
    else if (q->data.size - request <= Min_Size)
    {
        q->data.state = Busy;
        for (int i = 0; i < 10; i++)
        {
            q->data.name[i] = temp->data.name[i];
        }
        return OK;
    }
    else
    {
        temp->prior = q->prior;
        temp->next = q;
        temp->data.address = q->data.address;
        q->prior->next = temp;
        q->prior = temp;
        q->data.address += request;
        q->data.size = max;
        return OK;
    }
    return OK;
}

int Next_fit(int request)    //循环首次适应算法 
{
    //为申请作业开辟新空间且初始化
    LinkList temp = (LinkList)malloc(sizeof(LinkNode));
    temp->data.size = request;
    temp->data.state = Busy;
    cout << "请输入作业名：";
    cin >> temp->data.name;
    while (pn)
    {
        if (pn->data.state == Free && pn->data.size - request <= Min_Size && pn->data.size - request >= 0)
        {//有大小恰好合适的空闲块
            pn->data.state = Busy;
            for (int i = 0; i < 10; i++) 
            {
                pn->data.name[i] = temp->data.name[i];
            }
            return OK;
            break;
        }
        if (pn->data.state == Free && pn->data.size > request + Min_Size)
        {//有空闲块能满足需求且有剩余
            temp->prior = pn->prior;
            temp->next = pn;
            temp->data.address = pn->data.address;
            pn->prior->next = temp;
            pn->prior = temp;
            pn->data.address = temp->data.address + temp->data.size;
            pn->data.size -= request;
            return OK;
            break;
        }
        pn = pn->next;
        if (pn == NULL)
            pn = block_first;
    }
    return ERROR;
}


int free(int flag)//主存回收
{
    LinkNode* p = block_first;
    for (int i = 0; i <= flag; i++)
        if (p != NULL)
            p = p->next;
        else
            return ERROR;

    p->data.state = Free;
    if (p == block_last)
    {
        if (p->prior != block_first && p->prior->data.state == Free)//与前面的空闲块相连
        {
            p->prior->data.size += p->data.size;//空间扩充,合并为一个
            p = p->prior;
            p->next = NULL;
            block_last = p;
        }
    }
    else 
    {

        if (p->prior != block_first && p->prior->data.state == Free)//与前面的空闲块相连
        {
            p->prior->data.size += p->data.size;//空间扩充,合并为一个
            p->prior->next = p->next;//去掉原来被合并的p
            p->next->prior = p->prior;
            p = p->prior;
        }
        if (p->next != block_last && p->next->data.state == Free)//与后面的空闲块相连
        {
            p->data.size += p->next->data.size;//空间扩充,合并为一个
            p->next->next->prior = p;
            p->next = p->next->next;
        }
        if (p->next == block_last && p->next->data.state == Free)//与最后的空闲块相连
        {
            p->data.size += p->next->data.size;
            p->next = NULL;
        }
    }
    return OK;
}

int Combination()     //实现紧凑，合并碎片 
{
    LinkNode* p = block_first->next;
    int size = 0;
    while (p) 
    {
        if (p->data.state == Free && p != block_last)    //去除空闲分区 
        {
            size = size + p->data.size;
            p->next->prior = p->prior;
            p->prior->next = p->next;
        }
        else 
        {
            p->data.address = p->data.address - size;   //改变地址 
        }
        p = p->next;
    }
    if (block_last->data.state == Free) 
    {     //实现最后合并空闲分区 
        block_last->data.size += size;
    }
    else if (size != 0) 
    {                     //将所有空闲分区合并放在最后一个分区后面 
        LinkList temp = (LinkList)malloc(sizeof(LinkNode));
        block_last->next = temp;
        temp->prior = block_last;
        temp->next = NULL;
        temp->data.size = size;
        temp->data.address = block_last->data.address + block_last->data.size;
        block_last = temp;
        temp->data.state = Free;
    }
    pn = block_first->next;
    if (size == 0)   //判断是否有碎片 
    {
        return ERROR;
    }
    return OK;
}

void printNode()//显示主存分配情况
{
    int num = 0;
    printf("                        内存情况                        \n");
    cout << "======================================================\n\n";
    LinkNode* p = block_first->next;
    cout << "分区号\t起始地址\t分区大小\t状态\t作业名\n\n";
    while (p)
    {
        cout << "  " << num++ << "\t";
        cout << "  " << p->data.address << "\t\t";
        cout << " " << p->data.size << "KB\t\t";
        if (p->data.state == Free) 
        {
            cout << "空闲\n\n";
        }
        else 
        {
            cout << "已分配\t";
            cout << "  " << p->data.name << "\n\n";
        }


        p = p->next;
    }
    cout << "======================================================\n\n";
}
//最佳
void Operate1() 
{
    int choice;  //操作选择标记
    while (1)
    {
        menu1();
        scanf_s("%d", &choice);
        if (choice == 1)
            myMalloc1();
        // 分配内存
        else if (choice == 2)  // 内存回收
        {
            int flag;
            cout << "请输入您要释放的分区号：" << endl;
            cin >> flag;
            free(flag);
        }
        else if (choice == 3)
            printNode();
        else if (choice == 4)
        {
            if (Combination() == 0) 
            {
                cout << "无需合并碎片空间！" << endl;
            }
            else
            {
                cout << "成功合并碎片！" << endl;
            }
        }
        else if (choice == 5) 
        {
            Choose();
        }
        else if (choice == 6)
            break; //退出
        else //输入操作有误
        {
            cout << "输入有误，请重试！" << endl;
            continue;
        }
    }
}
//首次
void Operate2() 
{
    int choice;  //操作选择标记
    while (1)
    {
        menu2();
        scanf_s("%d", &choice);
        if (choice == 1)
            myMalloc2();
        // 分配内存
        else if (choice == 2)  // 内存回收
        {
            int flag;
            cout << "请输入您要释放的分区号：" << endl;
            cin >> flag;
            free(flag);
        }
        else if (choice == 3) 
            printNode();
        else if (choice == 4)
        {
            if (Combination() == 0)
            {
                cout << "无需合并碎片空间！" << endl;
            }
            else 
            {
                cout << "成功合并碎片！" << endl;
            }
        }
        else if (choice == 5) 
        {
            Choose();
        }
        else if (choice == 6)
            break; //退出
        else //输入操作有误
        {
            cout << "输入有误，请重试！" << endl;
            continue;
        }
    }
}
//循环首次
void Operate3()
{
    int choice;  //操作选择标记
    while (1)
    {
        menu3();
        scanf_s("%d", &choice);
        if (choice == 1) myMalloc3(); // 分配内存
        else if (choice == 2)  // 内存回收
        {
            int flag;
            cout << "请输入您要释放的分区号：" << endl;
            cin >> flag;
            free(flag);
        }
        else if (choice == 3) 
            printNode();
        else if (choice == 4)
        {
            if (Combination() == 0)
            {
                cout << "无需合并碎片空间！" << endl;
            }
            else 
            {
                cout << "成功合并碎片！" << endl;
            }
        }
        else if (choice == 5) 
        {
            Choose();
        }
        else if (choice == 6) 
            break; //退出
        else //输入操作有误
        {
            cout << "输入有误，请重试！" << endl;
            continue;
        }
    }
}
//最坏
void Operate4() 
{
    int choice;  //操作选择标记
    while (1)
    {
        menu4();
        scanf_s("%d", &choice);
        if (choice == 1) myMalloc4(); // 分配内存
        else if (choice == 2)  // 内存回收
        {
            int flag;
            cout << "请输入您要释放的分区号：" << endl;
            cin >> flag;
            free(flag);
        }
        else if (choice == 3) 
            printNode();
        else if (choice == 4)
        {
            if (Combination() == 0)
            {
                cout << "无需合并碎片空间！" << endl;
            }
            else 
            {
                cout << "成功合并碎片！" << endl;
            }
        }
        else if (choice == 5)
        {
            Choose();
        }
        else if (choice == 6)
            break; //退出
        else //输入操作有误
        {
            cout << "输入有误，请重试！" << endl;
            continue;
        }
    }
}

void  Choose() 
{
    int adaptChoice = 0;
    system("color 9E");
    do
    {
        printf("\n请选择适应的算法: \n");
        printf("1.最佳适应\n");
        printf("2.首次适应\n");
        printf("3.循环首次适应\n");
        printf("4.最坏适应\n");
        printf("\n");
        printf("请输入: ");
        scanf_s("%d", &adaptChoice);
        switch (adaptChoice)
        {
        case 1:
            cout << "*******************最佳适应算法**********************" << endl;
            Init(); //初始化内存状态 
            Operate1();
            return;
        case 2:
            cout << "*********************首次适应算法************************" << endl;
            Init(); //初始化内存状态 
            Operate2();
            return;
            cout << "********************************************************" << endl;

        case 3:
            cout << "*********************循环首次适应算法************************" << endl;
            Init(); //初始化内存状态 
            Operate3();
            return;
        case 4:
            cout << "*********************最坏适应算法************************" << endl;
            Init(); //初始化内存状态 
            Operate4();
            return;
        case 0:
            break;
        default:
            cout << "输入错误，请重新选择操作" << endl;
            break;
        }

    } while (adaptChoice != 0);
}

int main()//主函数
{
    Choose();
    return 0;
}

Answer 1

引自免费微信小程序：皆我百晓生

要在给定的代码基础上实现将申请内存和释放内存的操作序列保存到文本文件，并从文件中读取执行，你需要在程序中添加文件读写功能。这里提供一个简化的示例，展示了如何修改代码来完成这个目标。

首先，我们需要定义一个结构体Operation来存储操作类型、操作编号以及操作参数。然后，我们将在每个内存操作后将操作记录到文件中，并在程序启动时从文件中加载先前的操作。

以下是修改后的部分关键代码：

#include <fstream>
#include <sstream>

struct Operation {
    int type;  // 0: 分配内存，1: 释放内存
    int flag;  // 分区号
};

std::vector<Operation> operations;

// 在每次内存操作后，将操作记录到文件
void record_operation(Operation op) {
    std::ofstream outfile("memory_operations.txt", std::ios::app);
    if (outfile.is_open()) {
        outfile << op.type << " " << op.flag << std::endl;
        outfile.close();
    }
}

// 在程序开始时，从文件中读取操作并执行
void load_operations() {
    std::ifstream infile("memory_operations.txt");
    if (infile.is_open()) {
        string line;
        while (getline(infile, line)) {
            stringstream ss(line);
            int type, flag;
            ss >> type >> flag;
            Operation op = {type, flag};
            execute_operation(op);
        }
        infile.close();
    }
}

// 执行操作
void execute_operation(Operation op) {
    switch (op.type) {
        case 0: // 分配内存
            if (op.flag == 1)
                myMalloc1();
            else if (op.flag == 2)
                myMalloc2();
            else if (op.flag == 3)
                myMalloc3();
            else if (op.flag == 4)
                myMalloc4();
            break;
        case 1: // 释放内存
            free(op.flag);
            break;
        default:
            break;
    }
}

int main() {
    load_operations(); // 加载先前的操作
    Choose();
    return 0;
}

接下来，我们需要修改free()函数，以便它在释放内存后也更新操作记录：

int free(int flag) {
    ...
    // 在释放内存后，记录操作
    Operation op = {1, flag}; // 1 表示释放内存
    record_operation(op);
    return OK;
}

同样，对于内存分配函数，也需要在分配内存后记录操作：

int myMalloc1() {
    ...
    // 在分配内存后，记录操作
    Operation op = {0, 1}; // 0 表示分配内存，1 是适应算法的选择
    record_operation(op);
    return OK;
}

int myMalloc2() {
    ...
    // 在分配内存后，记录操作
    Operation op = {0, 2}; // 0 表示分配内存，2 是适应算法的选择
    record_operation(op);
    return OK;
}

int myMalloc3() {
    ...
    // 在分配内存后，记录操作
    Operation op = {0, 3}; // 0 表示分配内存，3 是适应算法的选择
    record_operation(op);
    return OK;
}

int myMalloc4() {
    ...
    // 在分配内存后，记录操作
    Operation op = {0, 4}; // 0 表示分配内存，4 是适应算法的选择
    record_operation(op);
    return OK;
}

这样，每次进行内存分配或释放操作时，都会将操作记录到memory_operations.txt文件中。当程序启动时，会自动从该文件中读取先前的操作并执行。注意，这个简化示例假设了每个操作都对应于一个明确的内存管理函数调用。如果你需要处理更复杂的情况，例如多个操作可能共享同一个内存管理函数，则需要对代码进行适当的调整。