首次适应算法c语言实现分配和回收过程

首次适应算法（First Fit）是一种内存分配算法，它从内存的起始地址开始查找，找到第一个能够容纳请求大小的空闲区域，并将其分配给请求。以下是使用C语言实现首次适应算法的分配和回收过程的示例代码：

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

#define MEM_SIZE 1000

char memory[MEM_SIZE];

typedef struct {
    int size;
    int is_free;
} block;

block* find_free_block(int size) {
    block* current_block = (block*)memory;
    while (current_block < (block*)(memory + MEM_SIZE)) {
        if (current_block->is_free && current_block->size >= size) {
            return current_block;
        }
        current_block = (block*)((char*)current_block + current_block->size + sizeof(block));
    }
    return NULL;
}

void split_block(block* b, int size) {
    block* new_block = (block*)((char*)b + size + sizeof(block));
    new_block->size = b->size - size - sizeof(block);
    new_block->is_free = 1;
    b->size = size;
    b->is_free = 0;
}

void* my_malloc(int size) {
    block* free_block = find_free_block(size);
    if (free_block == NULL) {
        return NULL;
    }
    if (free_block->size >= size + sizeof(block) + 1) {
        split_block(free_block, size);
    }
    return (void*)(free_block + 1);
}

void merge_blocks() {
    block* current_block = (block*)memory;
    while (current_block < (block*)(memory + MEM_SIZE)) {
        if (current_block->is_free) {
            block* next_block = (block*)((char*)current_block + current_block->size + sizeof(block));
            if (next_block < (block*)(memory + MEM_SIZE) && next_block->is_free) {
                current_block->size += next_block->size + sizeof(block);
            }
        }
        current_block = (block*)((char*)current_block + current_block->size + sizeof(block));
    }
}

void my_free(void* ptr) {
    block* b = (block*)ptr - 1;
    b->is_free = 1;
    merge_blocks();
}

int main() {
    block* initial_block = (block*)memory;
    initial_block->size = MEM_SIZE - sizeof(block);
    initial_block->is_free = 1;
    
    int* a = (int*)my_malloc(sizeof(int));
    *a = 42;
    printf("%d\n", *a);
    
    int* b = (int*)my_malloc(sizeof(int) * 10);
    for (int i = 0; i < 10; i++) {
        b[i] = i;
    }
    for (int i = 0; i < 10; i++) {
        printf("%d ", b[i]);
    }
    printf("\n");
    
    my_free(a);
    
    int* c = (int*)my_malloc(sizeof(int) * 5);
    for (int i = 0; i < 5; i++) {
        c[i] = i * 2;
    }
    for (int i = 0; i < 5; i++) {
        printf("%d ", c[i]);
    }
    printf("\n");
    
    my_free(b);
    my_free(c);
    
    return 0;
}

在上面的代码中，我们使用一个结构体`block`表示内存中的一个块，它包含块的大小和一个标志位，用于指示块是否空闲。`find_free_block`函数按顺序扫描内存中的块，找到第一个能够容纳请求大小的空闲区域，并返回该块的指针。`split_block`函数将一个块分成两个部分，其中一个部分分配给请求，另一个部分保持空闲状态。`my_malloc`函数分配请求大小的内存块，并在必要时分割块。`merge_blocks`函数合并相邻的空闲块。`my_free`函数释放内存块，并合并相邻的空闲块。

在主函数中，我们首先初始化一个大小为整个内存的初始块，并使用`my_malloc`函数分配一些内存块。然后我们使用`my_free`函数释放内存块，并再次使用`my_malloc`函数分配内存块。