C++如何实现一个简单的内存池_C++高性能内存分配管理策略-C++-PHP中文网

C++如何实现一个简单的内存池_C++高性能内存分配管理策略

冰火之心

发布： 2025-10-30 15:44:02

原创

780人浏览过

内存池通过预分配连续内存块并管理固定大小槽位，减少系统调用和碎片，提升分配效率。

c++如何实现一个简单的内存池_c++高性能内存分配管理策略

在C++中，内存池是一种用于提升内存分配效率的技术，特别适用于频繁申请和释放小块内存的场景。直接使用new和delete或malloc/free会产生大量系统调用和内存碎片，影响性能。通过实现一个简单的内存池，可以显著减少这些开销。

内存池的基本原理

内存池预先分配一大块连续内存，然后按固定大小切分成多个“槽”（slot），每个槽可用来存放对象。当程序请求内存时，从池中取出一个空闲槽；释放时，将槽归还给池，而不是交还给操作系统。这样避免了频繁调用系统分配器。

关键优势包括：

减少动态内存分配次数
降低内存碎片
提高缓存局部性
加快分配/释放速度（接近O(1)）

实现一个简单的固定大小内存池

下面是一个简化但实用的内存池实现，支持固定大小对象的分配与回收。

立即学习“C++免费学习笔记（深入）”；

#include <iostream>
#include <cstdlib>
<p>class MemoryPool {
private:
struct Block {
Block* next;
};</p><pre class='brush:php;toolbar:false;'>char*   memory_;        // 池的起始地址
Block*  free_list_;     // 空闲块链表
size_t  block_size_;    // 每个块的大小
size_t  pool_size_;     // 总块数
bool    initialized_;

登录后复制

public: MemoryPool(size_t block_size, size_t num_blocks) : blocksize(block_size), poolsize(numblocks), initialized(false) { if (blocksize < sizeof(Block)) { blocksize = sizeof(Block); // 至少能链接下一个指针 }

    memory_ = new char[block_size_ * pool_size_];
    free_list_ = nullptr;
    initialized_ = true;

    // 构建空闲链表：将所有块连起来
    for (size_t i = 0; i < pool_size_; ++i) {
        Block* block = reinterpret_cast<Block*>(memory_ + i * block_size_);
        block->next = free_list_;
        free_list_ = block;
    }
}

~MemoryPool() {
    delete[] memory_;
    memory_ = nullptr;
    free_list_ = nullptr;
}

void* allocate() {
    if (!free_list_) {
        return std::malloc(block_size_);  // 池满则回退到malloc
    }
    Block* head = free_list_;
    free_list_ = free_list_->next;
    return head;
}

void deallocate(void* ptr) {
    if (!ptr) return;

    // 判断是否在池范围内
    char* p = static_cast<char*>(ptr);
    if (p >= memory_ && p < memory_ + block_size_ * pool_size_) {
        Block* block = reinterpret_cast<Block*>(ptr);
        block->next = free_list_;
        free_list_ = block;
    } else {
        std::free(ptr);  // 不属于池的内存，用free释放
    }
}

登录后复制

};

这个内存池构造时分配一块连续内存，并将它们组织成单向链表。每次allocate()从链表头取一个块，deallocate()将其重新插入链表头部。

存了个图

视频图片解析/字幕/剪辑，视频高清保存/图片源图提取

查看详情

如何使用该内存池

假设我们要管理大量Point对象：

struct Point {
    float x, y;
    Point(float x = 0, float y = 0) : x(x), y(y) {}
};
<p>int main() {
MemoryPool pool(sizeof(Point), 100);</p><pre class='brush:php;toolbar:false;'>// 分配
Point* p1 = new (pool.allocate()) Point(1.0f, 2.0f);
Point* p2 = new (pool.allocate()) Point(3.0f, 4.0f);

std::cout << p1->x << ", " << p1->y << "\n";
std::cout << p2->x << ", " << p2->y << "\n";

// 回收
p1->~Point();
pool.deallocate(p1);

p2->~Point();
pool.deallocate(p2);

return 0;

登录后复制

}

注意这里使用了定位new语法，在预分配的内存上构造对象。析构时需显式调用析构函数，再将内存返还给池。