写一个关于操作系统动态分配算法的代码实验分析

以下是一个C++实现的动态分配算法的代码示例，涉及到了首次适应算法（First Fit）、最佳适应算法（Best Fit）和最坏适应算法（Worst Fit）：

#include <iostream>
#include <vector>
using namespace std;

// 进程结构体
struct Process {
    int pid;  // 进程ID
    int size; // 进程需要的内存空间大小
};

// 内存块结构体
struct MemoryBlock {
    int start; // 内存块起始地址
    int size;  // 内存块大小
    bool free; // 是否空闲
};

// 首次适应算法
void firstFit(vector<MemoryBlock>& memory, Process& process) {
    for (int i = 0; i < memory.size(); i++) {
        if (memory[i].free && memory[i].size >= process.size) {
            // 找到了空闲内存块
            process.pid = i; // 把进程ID设置为内存块的下标
            memory[i].free = false; // 把内存块标记为已占用
            break;
        }
    }
}

// 最佳适应算法
void bestFit(vector<MemoryBlock>& memory, Process& process) {
    int minSize = INT_MAX; // 最小空闲内存块大小
    int index = -1; // 最小空闲内存块的下标
    for (int i = 0; i < memory.size(); i++) {
        if (memory[i].free && memory[i].size >= process.size && memory[i].size < minSize) {
            // 找到了更小的空闲内存块
            minSize = memory[i].size;
            index = i;
        }
    }
    if (index != -1) {
        // 找到了空闲内存块
        process.pid = index; // 把进程ID设置为内存块的下标
        memory[index].free = false; // 把内存块标记为已占用
    }
}

// 最坏适应算法
void worstFit(vector<MemoryBlock>& memory, Process& process) {
    int maxSize = INT_MIN; // 最大空闲内存块大小
    int index = -1; // 最大空闲内存块的下标
    for (int i = 0; i < memory.size(); i++) {
        if (memory[i].free && memory[i].size >= process.size && memory[i].size > maxSize) {
            // 找到了更大的空闲内存块
            maxSize = memory[i].size;
            index = i;
        }
    }
    if (index != -1) {
        // 找到了空闲内存块
        process.pid = index; // 把进程ID设置为内存块的下标
        memory[index].free = false; // 把内存块标记为已占用
    }
}

int main() {
    int memorySize = 100; // 内存总大小
    vector<MemoryBlock> memory; // 内存块数组
    memory.push_back({0, memorySize, true}); // 初始化一块整个内存大小的空闲内存块
    vector<Process> processes = {{-1, 20}, {-1, 30}, {-1, 40}}; // 进程数组，每个进程需要的内存空间不同

    // 首次适应算法
    for (int i = 0; i < processes.size(); i++) {
        firstFit(memory, processes[i]);
        if (processes[i].pid != -1) {
            cout << "进程" << i << "分配到了内存块" << processes[i].pid << endl;
        } else {
            cout << "进程" << i << "没有分配到内存块" << endl;
        }
    }

    // 最佳适应算法
    memory.clear();
    memory.push_back({0, memorySize, true}); // 先清空内存块数组，重新初始化一块整个内存大小的空闲内存块
    for (int i = 0; i < processes.size(); i++) {
        bestFit(memory, processes[i]);
        if (processes[i].pid != -1) {
            cout << "进程" << i << "分配到了内存块" << processes[i].pid << endl;
        } else {
            cout << "进程" << i << "没有分配到内存块" << endl;
        }
    }

    // 最坏适应算法
    memory.clear();
    memory.push_back({0, memorySize, true}); // 先清空内存块数组，重新初始化一块整个内存大小的空闲内存块
    for (int i = 0; i < processes.size(); i++) {
        worstFit(memory, processes[i]);
        if (processes[i].pid != -1) {
            cout << "进程" << i << "分配到了内存块" << processes[i].pid << endl;
        } else {
            cout << "进程" << i << "没有分配到内存块" << endl;
        }
    }

    return 0;
}

以上代码实现了首次适应算法、最佳适应算法和最坏适应算法，对于每个进程，先尝试使用这些算法分配内存空间，如果找到了空闲内存块，则把进程ID设置为内存块的下标，并把内存块标记为已占用。最后输出每个进程是否成功分配到内存块。