展示一段c语言代码使用首次适应算法实现固定长度内存的分配与回收

下面是一段C语言代码，用于展示如何使用首次适应算法实现固定长度内存的分配与回收：

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

#define MEM_SIZE 100 // 定义内存块大小

char mem[MEM_SIZE]; // 定义内存块

typedef struct node { // 定义内存块节点结构体
    int size; // 内存块大小
    int used; // 是否被使用
    struct node *next; // 指向下一个节点
} Node;

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

void init_mem() { // 初始化内存块链表
    head = (Node *)mem;
    head->size = MEM_SIZE - sizeof(Node);
    head->used = 0;
    head->next = NULL;
}

void *my_malloc(int size) { // 内存分配函数
    Node *p = head;
    Node *prev = NULL;
    while (p != NULL && (p->size < size || p->used == 1)) { // 找到第一个可用的内存块
        prev = p;
        p = p->next;
    }
    if (p == NULL) { // 没有可用的内存块
        return NULL;
    }
    if (p->size > size + sizeof(Node)) { // 分割内存块
        Node *new_node = (Node *)((char *)p + sizeof(Node) + size);
        new_node->size = p->size - size - sizeof(Node);
        new_node->used = 0;
        new_node->next = p->next;
        p->size = size;
        p->used = 1;
        p->next = new_node;
    } else { // 不需要分割内存块
        p->used = 1;
    }
    return (void *)((char *)p + sizeof(Node));
}

void my_free(void *ptr) { // 内存回收函数
    Node *p = (Node *)((char *)ptr - sizeof(Node));
    p->used = 0;
    if (p->next != NULL && p->next->used == 0) { // 合并相邻的空闲内存块
        p->size += sizeof(Node) + p->next->size;
        p->next = p->next->next;
    }
    if (p != head && p->used == 0 && p->next == NULL) { // 释放最后一个空闲内存块的情况
        Node *prev = head;
        while (prev->next != p) {
            prev = prev->next;
        }
        prev->next = NULL;
    }
}

int main() {
    init_mem(); // 初始化内存块链表
    int *p1 = (int *)my_malloc(sizeof(int)); // 分配内存
    if (p1 == NULL) {
        printf("memery out\n");
        return 1;
    }
    *p1 = 10;
    printf("p1=%d\n", *p1);
    int *p2 = (int *)my_malloc(sizeof(int)); // 分配内存
    if (p2 == NULL) {
        printf("memery out\n");
        return 1;
    }
    *p2 = 20;
    printf("p2=%d\n", *p2);
    my_free(p1); // 释放内存
    my_free(p2); // 释放内存
    return 0;
}

上述代码中，我们首先定义了一个内存块大小为100的内存池，并且使用结构体Node来表示每一个内存块节点。然后，我们定义了一个内存块链表头指针head，并且实现了初始化内存块链表的函数init_mem()。

接下来，我们实现了内存分配函数my_malloc()，该函数使用首次适应算法来查找第一个可用的内存块，并且在找到可用的内存块后，根据需要对内存块进行分割。最后，我们实现了内存回收函数my_free()，该函数释放指定内存块，并且合并相邻的空闲内存块。

在main()函数中，我们首先调用init_mem()函数初始化内存块链表，然后使用my_malloc()函数分配内存，并且将分配的内存用指针p1和p2指向。接着，我们在控制台输出p1和p2的值，并且分别使用my_free()函数释放内存。最后，我们返回0表示程序运行成功