C 语言内存池实现，包含内存池的创建、销毁、分配和释放等操作，使用了链表来管理内存块

#include <stdlib.h>

typedef struct mempool_block {
    struct mempool_block* next;
    char* data;
} mempool_block_t;

typedef struct mempool {
    size_t block_size;
    size_t num_blocks;
    mempool_block_t* blocks;
    char* free_data;
} mempool_t;

mempool_t* mempool_create(size_t block_size, size_t num_blocks) {
    mempool_t* pool = malloc(sizeof(mempool_t));
    if (pool == NULL) {
        return NULL;
    }
    pool->block_size = block_size;
    pool->num_blocks = num_blocks;
    pool->blocks = malloc(num_blocks * sizeof(mempool_block_t));
    if (pool->blocks == NULL) {
        free(pool);
        return NULL;
    }
    for (size_t i = 0; i < num_blocks; ++i) {
        pool->blocks[i].data = malloc(block_size);
        if (pool->blocks[i].data == NULL) {
            for (size_t j = 0; j < i; ++j) {
                free(pool->blocks[j].data);
            }
            free(pool->blocks);
            free(pool);
            return NULL;
        }
        pool->blocks[i].next = &pool->blocks[i + 1];
    }
    pool->blocks[num_blocks - 1].next = NULL;
    pool->free_data = pool->blocks[0].data;
    return pool;
}

void mempool_destroy(mempool_t* pool) {
    for (size_t i = 0; i < pool->num_blocks; ++i) {
        free(pool->blocks[i].data);
    }
    free(pool->blocks);
    free(pool);
}

void* mempool_alloc(mempool_t* pool, size_t size) {
    if (size > pool->block_size) {
        return NULL;
    }
    if (pool->free_data == NULL) {
        return NULL;
    }
    void* data = pool->free_data;
    pool->free_data = pool->free_data + pool->block_size;
    if (pool->free_data >= (char*)(pool->blocks + pool->num_blocks)) {
        pool->free_data = NULL;
    }
    return data;
}

void mempool_free(mempool_t* pool, void* data) {
    if (data < (void*)pool->blocks || data >= (void*)(pool->blocks + pool->num_blocks)) {
        return;
    }
    char* block_data = (char*)data;
    size_t block_index = (block_data - pool->blocks[0].data) / pool->block_size;
    pool->blocks[block_index].next = pool->free_data;
    pool->free_data = block_data;
}

应用示例:

// 创建一个内存池，每个内存块大小为 64 字节，共有 10 个内存块
mempool_t* pool = mempool_create(64, 10);

// 分配一个内存块
void* data1 = mempool_alloc(pool, 32);

// 分配另一个内存块
void* data2 = mempool_alloc(pool, 64);

// 释放第一个内存块
mempool_free(pool, data1);

// 销毁内存池
mempool_destroy(pool);