动态分区分配实验c语言

好的，这是一个关于动态分区分配的实验的C语言代码示例：

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

#define MAX_MEM_SIZE 1024 // 内存大小
#define MIN_MEM_SIZE 4 // 最小内存块大小

// 内存块结构体
typedef struct _mem_block {
    int size; // 内存块大小
    int is_free; // 是否空闲
    struct _mem_block* next; // 下一个内存块的地址
} mem_block;

mem_block* mem_start = NULL; // 内存起始地址

// 初始化内存
void init_mem() {
    mem_start = (mem_block*)malloc(MAX_MEM_SIZE);
    mem_start->size = MAX_MEM_SIZE - sizeof(mem_block);
    mem_start->is_free = 1;
    mem_start->next = NULL;
}

// 分配内存块
void* my_malloc(int size) {
    mem_block* p = mem_start;
    mem_block* prev = NULL;

    // 遍历内存块链表，查找符合大小并且空闲的内存块
    while (p != NULL) {
        if (p->size >= size && p->is_free) {
            // 如果内存块大小大于等于需求大小，且空闲，则分配这个内存块
            if (p->size - size >= MIN_MEM_SIZE + sizeof(mem_block)) {
                // 如果剩余内存大小足够分配一个新的内存块，则分裂出一个新的内存块出来
                mem_block* new_block = (mem_block*)((char*)p + sizeof(mem_block) + size);
                new_block->size = p->size - sizeof(mem_block) - size;
                new_block->is_free = 1;
                new_block->next = p->next;
                p->next = new_block;
                p->size = size;
            }
            p->is_free = 0;
            return (void*)((char*)p + sizeof(mem_block));
        }
        prev = p;
        p = p->next;
    }

    // 没有符合条件的内存块，返回NULL
    return NULL;
}

// 释放内存块
void my_free(void* p) {
    mem_block* block = (mem_block*)((char*)p - sizeof(mem_block));
    block->is_free = 1;

    // 尝试合并前面的空闲内存块
    mem_block* prev = mem_start;
    mem_block* curr = prev->next;
    while (curr != NULL) {
        if (prev->is_free && curr->is_free) {
            prev->size += sizeof(mem_block) + curr->size;
            prev->next = curr->next;
            curr = prev->next;
        } else {
            prev = curr;
            curr = curr->next;
        }
    }

    // 尝试合并后面的空闲内存块
    prev = mem_start;
    curr = prev->next;
    while (curr != NULL) {
        if (curr->is_free && (void*)((char*)prev + sizeof(mem_block) + prev->size) == (void*)curr) {
            prev->size += sizeof(mem_block) + curr->size;
            prev->next = curr->next;
            curr = prev->next;
        } else {
            prev = curr;
            curr = curr->next;
        }
    }
}

int main() {
    init_mem();

    // 分配两个内存块
    int* p1 = (int*)my_malloc(100);
    int* p2 = (int*)my_malloc(200);

    printf("p1 = %p\n", p1);
    printf("p2 = %p\n", p2);

    // 释放第一个内存块
    my_free(p1);

    // 再分配一个内存块
    int* p3 = (int*)my_malloc(50);

    printf("p3 = %p\n", p3);

    // 释放所有内存块
    my_free(p2);
    my_free(p3);

    return 0;
}

这段代码实现了一个简单的动态分区分配算法，使用了链表来管理内存块，支持分配和释放内存块，并且在释放内存块时尝试合并相邻的空闲内存块，以减少内存碎片。