语言编写储存器管理实验

当然可以，以下是一个简单的C语言程序来模拟储存器管理实验的过程，它可以实现内存的动态分配和释放：

#include <stdio.h>
#include <stdlib.h>

#define MEMORY_SIZE 1000 // 定义内存块大小
char memory[MEMORY_SIZE]; // 内存块数组

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

// 定义内存块头指针
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 = (MemoryBlock *)malloc(sizeof(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);
    printf("p1=%p, p2=%p, p3=%p\n", p1, p2, p3);
    my_free(p2, 200);
    void *p4 = my_malloc(400);
    printf("p4=%p\n", p4);
    return 0;
}

上述代码实现了一个简单的内存块链表来管理内存，可以通过 `my_malloc()` 函数来动态分配内存块，通过 `my_free()` 函数来释放内存块。具体的实现过程和注释已在代码中说明。