C语言中如何实现内存池 C语言自定义内存管理方案设计

malloc

free

malloc

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

typedef struct MemBlock {
    struct MemBlock* next;
    size_t size;
} MemBlock;

typedef struct MemPool {
    MemBlock* freeList;
    size_t blockSize;
    size_t poolSize;
    char* poolStart;
} MemPool;

MemPool* createMemPool(size_t blockSize, size_t numBlocks) {
    MemPool* pool = (MemPool*)malloc(sizeof(MemPool));
    if (!pool) return NULL;

    pool->blockSize = blockSize;
    pool->poolSize = blockSize * numBlocks;
    pool->poolStart = (char*)malloc(pool->poolSize);

    if (!pool->poolStart) {
        free(pool);
        return NULL;
    }

    pool->freeList = (MemBlock*)pool->poolStart;
    pool->freeList->next = NULL;
    pool->freeList->size = pool->poolSize;

    return pool;
}

void* allocMem(MemPool* pool) {
    MemBlock* current = pool->freeList;
    MemBlock* previous = NULL;

    while (current) {
        if (current->size >= pool->blockSize + sizeof(MemBlock)) { // 确保分割后剩余空间足够
            // 分割内存块
            char* blockStart = (char*)current + sizeof(MemBlock); // 返回给用户的内存起始位置
            size_t remainingSize = current->size - pool->blockSize - sizeof(MemBlock);

            if (remainingSize > sizeof(MemBlock)) { // 确保分割后剩余空间足够容纳一个新的 MemBlock 结构
                MemBlock* newBlock = (MemBlock*)(blockStart + pool->blockSize);
                newBlock->next = current->next;
                newBlock->size = remainingSize - sizeof(MemBlock);

                current->size = pool->blockSize + sizeof(MemBlock); // 更新当前块的大小

                if (previous) {
                    previous->next = newBlock;
                } else {
                    pool->freeList = newBlock;
                }
                return blockStart;
            } else { // 剩余空间不足，直接分配整个块
                 if (previous) {
                    previous->next = current->next;
                } else {
                    pool->freeList = current->next;
                }
                return (char*)current + sizeof(MemBlock);
            }

        }
        previous = current;
        current = current->next;
    }

    return NULL; // 内存池已满
}


void freeMem(MemPool* pool, void* block) {
    if (!block) return;

    MemBlock* blockToFree = (MemBlock*)((char*)block - sizeof(MemBlock));
    blockToFree->next = pool->freeList;
    pool->freeList = blockToFree;

    // 尝试合并相邻的空闲块（简单起见，这里省略合并逻辑）
}

void destroyMemPool(MemPool* pool) {
    free(pool->poolStart);
    free(pool);
}


int main() {
    size_t blockSize = 128;
    size_t numBlocks = 10;
    MemPool* pool = createMemPool(blockSize, numBlocks);

    if (!pool) {
        printf("Failed to create memory pool.\n");
        return 1;
    }

    void* block1 = allocMem(pool);
    if (block1) {
        printf("Allocated block1 at: %p\n", block1);
    } else {
        printf("Failed to allocate block1.\n");
    }

    void* block2 = allocMem(pool);
    if (block2) {
        printf("Allocated block2 at: %p\n", block2);
    } else {
        printf("Failed to allocate block2.\n");
    }

    freeMem(pool, block1);
    printf("Freed block1.\n");

    void* block3 = allocMem(pool);
    if (block3) {
        printf("Allocated block3 at: %p\n", block3);
    } else {
        printf("Failed to allocate block3.\n");
    }

    destroyMemPool(pool);
    printf("Memory pool destroyed.\n");

    return 0;
}

malloc

free