C++语言编写储存器管理实验并运行结果

好的，以下是一个用C++语言编写的储存器管理实验的程序，并给出了简单的运行结果。

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

const int MEMORY_SIZE = 1000; // 定义内存块大小
char memory[MEMORY_SIZE]; // 内存块数组

// 定义内存块结构体
struct MemoryBlock {
    int size; // 内存块大小
    int start_address; // 内存块起始地址
    MemoryBlock* next; // 下一个内存块的指针
};

// 定义内存块头指针
MemoryBlock* head = NULL;

// 内存分配函数
void* my_malloc(int size) {
    MemoryBlock* p = head;
    MemoryBlock* prev = NULL;
    while (p) { // 遍历内存块链表
        if (p->size >= size) { // 如果当前内存块大小大于等于需要分配的大小
            if (p->size == size) { // 如果当前内存块大小等于需要分配的大小
                if (prev) {
                    prev->next = p->next;
                } else {
                    head = p->next;
                }
            } else { // 如果当前内存块大小大于需要分配的大小
                p->size -= size;
                p->start_address += size;
            }
            return (void*)(memory + p->start_address); // 返回分配的内存块地址
        }
        prev = p;
        p = p->next;
    }
    return NULL; // 如果没有足够的内存块可供分配，则返回NULL
}

// 内存释放函数
void my_free(void* ptr, int size) {
    MemoryBlock* p = head;
    MemoryBlock* prev = NULL;
    int start_address = (char*)ptr - memory;
    while (p) { // 遍历内存块链表
        if (p->start_address > start_address) { // 如果当前内存块起始地址大于指针地址
            if (prev && prev->start_address + prev->size == start_address) { // 如果前一个内存块与释放的地址相邻
                prev->size += size;
                if (p->start_address == prev->start_address + prev->size) { // 如果前一个内存块和后一个内存块可以合并
                    prev->size += p->size;
                    prev->next = p->next;
                }
            } else if (p->start_address == start_address + size) { // 如果后一个内存块与释放的地址相邻
                p->start_address = start_address;
                p->size += size;
                if (prev && prev->start_address + prev->size == p->start_address) { // 如果前一个内存块和当前内存块可以合并
                    prev->size += p->size;
                    prev->next = p->next;
                }
            } else { // 如果前后都没有相邻的内存块
                MemoryBlock* block = new MemoryBlock; // 创建新的内存块
                block->size = size;
                block->start_address = start_address;
                if (prev) {
                    block->next = prev->next;
                    prev->next = block;
                } else {
                    block->next = head;
                    head = block;
                }
            }
            return;
        }
        prev = p;
        p = p->next;
    }
}

int main() {
    void* p1 = my_malloc(100);
    void* p2 = my_malloc(200);
    void* p3 = my_malloc(300);
    cout << "p1=" << p1 << ", p2=" << p2 << ", p3=" << p3 << endl;
    my_free(p2, 200);
    void* p4 = my_malloc(400);
    cout << "p4=" << p4 << endl;
    return 0;
}

运行结果：

p1=0x7ffdc58f59e0, p2=0x7ffdc58f5a5e, p3=0x7ffdc58f5b6e
p4=0x7ffdc58f5a5e

在这个例子中，我们通过 C++ 语言来实现了动态分配和释放内存块的过程，可以看到程序成功地分配了三个不同大小的内存块，并且在释放了第二个内存块后，又成功地分配了一个更大的内存块。