用c实现可变式分区管理

可变式分区管理是一种常见的内存分配方式，可以动态地分配和释放内存。在C语言中，可以使用malloc()和free()函数来实现可变式分区管理。

以下是一个简单的示例代码，实现了可变式分区管理：

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

#define MEMORY_SIZE 1024 // 内存大小

// 内存块结构体
typedef struct block {
    int size; // 内存块大小
    int free; // 是否空闲
    struct block *next; // 下一个内存块
} block_t;

// 内存池
static char memory[MEMORY_SIZE];

// 内存块链表头指针
static block_t *head = NULL;

// 初始化内存池
void init_memory_pool() {
    head = (block_t*)memory;
    head->size = MEMORY_SIZE - sizeof(block_t);
    head->free = 1;
    head->next = NULL;
}

// 分配内存
void* my_malloc(int size) {
    block_t *p = head, *prev = NULL;

    while (p != NULL) {
        if (p->free && p->size >= size) {
            if (p->size >= size + sizeof(block_t)) {
                // 内存块可以分割
                block_t *new_block = (block_t*)((char*)p + sizeof(block_t) + size);
                new_block->size = p->size - size - sizeof(block_t);
                new_block->free = 1;
                new_block->next = p->next;

                p->size = size;
                p->free = 0;
                p->next = new_block;
            } else {
                // 内存块不需要分割
                p->free = 0;
            }

            return (void*)((char*)p + sizeof(block_t));
        }

        prev = p;
        p = p->next;
    }

    // 没有空闲的内存块
    return NULL;
}

// 释放内存
void my_free(void *ptr) {
    if (ptr == NULL) {
        return;
    }

    block_t *p = (block_t*)((char*)ptr - sizeof(block_t));
    p->free = 1;

    // 合并相邻的空闲内存块
    block_t *prev = NULL, *next = NULL;
    for (block_t *curr = head; curr != NULL; curr = curr->next) {
        if (curr->free) {
            if (next == NULL && curr > p) {
                next = curr;
            }
            if (curr < p) {
                prev = curr;
            }
        }
    }
    if (prev != NULL && prev->free) {
        prev->size += p->size + sizeof(block_t);
        prev->next = p->next;
        p = prev;
    }
    if (next != NULL && next->free) {
        p->size += next->size + sizeof(block_t);
        p->next = next->next;
    }
}

// 打印内存块信息
void print_blocks() {
    printf("Memory blocks:\n");
    for (block_t *p = head; p != NULL; p = p->next) {
        printf("  block at %p, size %d, %s\n", p, p->size, p->free ? "free" : "used");
    }
}

int main() {
    init_memory_pool();

    void *p1 = my_malloc(64);
    printf("p1 = %p\n", p1);
    print_blocks();

    void *p2 = my_malloc(128);
    printf("p2 = %p\n", p2);
    print_blocks();

    my_free(p1);
    print_blocks();

    void *p3 = my_malloc(256);
    printf("p3 = %p\n", p3);
    print_blocks();

    my_free(p2);
    my_free(p3);
    print_blocks();

    return 0;
}

在这个示例代码中，我们定义了一个内存块结构体，它包含了内存块的大小、是否空闲以及下一个内存块的指针。我们也定义了一个内存池，它是一个字符数组，用于存储所有的内存块。在程序开始时，我们将内存池中的第一个内存块作为链表头。

在分配内存时，我们遍历内存块链表，查找一个空闲的内存块，如果找到了大小足够的内存块，就将它标记为已使用，并返回它的指针。如果这个内存块大小超过所需大小，就将它分割成两个内存块，其中一个是已使用的内存块，另一个是空闲的内存块。

在释放内存时，我们将要释放的内存块标记为未使用，并查找相邻的空闲内存块，将它们合并成一个更大的空闲内存块。

在程序运行过程中，我们可以使用print_blocks()函数来打印所有的内存块信息，以便调试和验证。