c语言实现可变式分区 最先适应法

可变式分区是一种内存分配方式，它将内存分为多个区域，并且每个区域的大小可以动态变化。最先适应法是一种常见的内存分配算法，它会从内存空闲区域中找到第一个大于等于请求大小的空闲区域进行分配。

以下是使用C语言实现可变式分区最先适应法的示例代码：

#include <stdio.h>

#define MAX_SIZE 1000 // 内存总大小

struct block {
    int size;
    int start;
    int end;
    int status; // 0表示空闲，1表示已分配
};

struct block memory[MAX_SIZE];

void init_memory() {
    memory[0].size = MAX_SIZE;
    memory[0].start = 0;
    memory[0].end = MAX_SIZE - 1;
    memory[0].status = 0;
}

void display_memory() {
    for (int i = 0; i < MAX_SIZE; i++) {
        if (memory[i].status == 0) {
            printf("Block %d: size = %d, start = %d, end = %d (free)\n", i, memory[i].size, memory[i].start, memory[i].end);
        } else {
            printf("Block %d: size = %d, start = %d, end = %d (allocated)\n", i, memory[i].size, memory[i].start, memory[i].end);
        }
    }
}

int allocate_memory(int size) {
    for (int i = 0; i < MAX_SIZE; i++) {
        if (memory[i].status == 0 && memory[i].size >= size) {
            if (memory[i].size == size) { // 分配整个空闲区域
                memory[i].status = 1;
                return memory[i].start;
            } else { // 拆分空闲区域
                int index = i + 1;
                while (memory[index].status == 1) { // 找到第一个空闲块
                    index++;
                }
                int old_size = memory[i].size;
                int old_end = memory[i].end;
                memory[i].size = size;
                memory[i].end = memory[i].start + size - 1;
                memory[index].size = old_size - size;
                memory[index].start = memory[i].end + 1;
                memory[index].end = old_end;
                memory[index].status = 0;
                memory[i].status = 1;
                return memory[i].start;
            }
        }
    }
    return -1; // 分配失败
}

void free_memory(int start) {
    for (int i = 0; i < MAX_SIZE; i++) {
        if (memory[i].status == 1 && memory[i].start == start) {
            memory[i].status = 0;
            return;
        }
    }
}

int main() {
    init_memory();
    display_memory();

    int p1 = allocate_memory(100);
    printf("Allocate 100 bytes at %d\n", p1);
    display_memory();

    int p2 = allocate_memory(200);
    printf("Allocate 200 bytes at %d\n", p2);
    display_memory();

    int p3 = allocate_memory(300);
    printf("Allocate 300 bytes at %d\n", p3);
    display_memory();

    free_memory(p1);
    printf("Free the block at %d\n", p1);
    display_memory();

    int p4 = allocate_memory(50);
    printf("Allocate 50 bytes at %d\n", p4);
    display_memory();

    return 0;
}

该示例代码使用结构体数组来模拟内存分区，其中每个结构体表示一个内存块。`init_memory()` 函数用于初始化内存分区，将整个内存空间都置为空闲状态。`display_memory()` 函数用于显示当前内存分配情况。`allocate_memory(size)` 函数用于分配指定大小的内存块，并返回其起始地址。`free_memory(start)` 函数用于释放指定起始地址的内存块。

在 `allocate_memory(size)` 函数中，首先遍历整个内存区域，找到第一个大小大于等于请求大小的空闲区域。如果找到了合适的空闲区域，则根据请求大小进行分配。如果分配的大小正好等于空闲区域大小，则直接将该区域标记为已分配。否则，将这个空闲区域拆分成两个部分，一个部分被分配，另一个部分仍然保持空闲状态。

在 `free_memory(start)` 函数中，遍历整个内存区域，找到指定起始地址的内存块，并将其状态标记为空闲。

最后的 `main()` 函数演示了如何使用这些函数来进行内存分配和释放，并且在每个操作后都打印当前内存分区情况。