C++如何实现一个简单的内存池

C++内存池的核心设计思路

内存池的核心思想是提前向系统申请一大块连续内存，后续程序需要分配内存时直接从这块预分配的内存中划分，释放时也不立即归还给系统，而是放回内存池的空闲队列中重复利用，从而减少系统调用带来的开销。

基础内存池的结构定义

我们首先定义一个简单的内存池类，内部维护预分配的内存块和空闲链表，这里以固定大小的内存块分配为例，适合管理大量相同大小的对象。

#include <cstddef>
#include <iostream>

class SimpleMemoryPool {
private:
    // 内存块头部，用于链接空闲块
    struct BlockHeader {
        BlockHeader* next;
    };
    
    BlockHeader* free_list;  // 空闲链表头指针
    char* memory_chunk;      // 预分配的内存块起始地址
    size_t block_size;       // 每个内存块的大小
    size_t block_count;      // 预分配的内存块数量
    
public:
    // 构造函数：预分配内存
    SimpleMemoryPool(size_t block_sz, size_t block_cnt) 
        : free_list(nullptr), block_size(block_sz), block_count(block_cnt) {
        // 每个块至少需要能存放一个BlockHeader
        if (block_size < sizeof(BlockHeader)) {
            block_size = sizeof(BlockHeader);
        }
        // 申请一大块连续内存
        memory_chunk = new char[block_size * block_count];
        // 初始化空闲链表，将所有块串起来
        for (size_t i = 0; i < block_count; ++i) {
            BlockHeader* block = reinterpret_cast<BlockHeader*>(memory_chunk + i * block_size);
            block->next = free_list;
            free_list = block;
        }
    }
    
    // 析构函数：释放预分配的内存
    ~SimpleMemoryPool() {
        delete[] memory_chunk;
        free_list = nullptr;
    }
    
    // 分配内存
    void* allocate() {
        if (free_list == nullptr) {
            std::cerr << "内存池已无可用块" << std::endl;
            return nullptr;
        }
        // 从空闲链表头部取一个块
        BlockHeader* alloc_block = free_list;
        free_list = free_list->next;
        return alloc_block;
    }
    
    // 回收内存
    void deallocate(void* ptr) {
        if (ptr == nullptr) return;
        // 将回收的块插回空闲链表头部
        BlockHeader* block = reinterpret_cast<BlockHeader*>(ptr);
        block->next = free_list;
        free_list = block;
    }
};

内存池的使用示例

下面演示如何使用上面实现的内存池来分配和回收内存，对比直接使用new和delete的差异。

// 测试内存池的使用
int main() {
    // 创建内存池，每个块大小32字节，预分配100个块
    SimpleMemoryPool pool(32, 100);
    
    // 从内存池分配内存
    void* p1 = pool.allocate();
    void* p2 = pool.allocate();
    std::cout << "分配得到的内存地址: " << p1 << ", " << p2 << std::endl;
    
    // 回收内存
    pool.deallocate(p1);
    pool.deallocate(p2);
    
    // 再次分配，会复用之前回收的块
    void* p3 = pool.allocate();
    std::cout << "复用回收块得到的内存地址: " << p3 << std::endl;
    
    return 0;
}

内存池的优化方向

上述实现是最基础的内存池，实际使用中可以根据需求做更多优化：

• 支持不同大小的内存块分配，可以维护多个不同规格的内存池
• 增加线程安全机制，给空闲链表操作加锁，适配多线程场景
• 当内存池不足时，支持动态扩容，避免分配失败
• 添加内存泄漏检测机制，记录已分配未回收的块信息

内存池的适用场景

内存池并不是所有场景都适用，以下场景使用内存池能获得明显的性能提升：

• 程序中需要频繁创建和销毁大量相同大小的对象，比如网络请求处理中的数据包对象
• 对内存分配延迟要求高的场景，比如实时音视频处理、游戏引擎中的对象管理
• 需要减少内存碎片化的场景，预分配连续内存可以降低系统内存碎片的产生

注意：如果程序中内存分配频率很低，或者对象大小差异很大，使用内存池反而可能增加内存占用，需要根据实际场景选择是否使用。

C++memory_pool内存管理高性能分配修改时间：2026-06-21 21:09:24