C++设计一个简单内存池的全过程

下面我将详细讲解C++设计一个简单内存池的全过程。

概述

内存池是为了提高内存分配与释放效率而提出的一种技术。一般情况下，内存池会提前分配一定的内存，并将分配出的内存按照一定的规则进行管理。当需要内存时，内存池会从已经预分配的内存中寻找可以使用的内存块。当不需要使用某个内存块时，该内存块会被归还给内存池进行管理。

下面我们将按照以下步骤设计简单的内存池。

步骤

第一步：先分配一定区域内存

首先，我们需要设计一个类来进行内存池的管理。在构造函数中，我们先分配一定区域的内存。用下面的代码实现：

class MemoryPool {
public:
    MemoryPool(size_t size, size_t block_size);
    ~MemoryPool();
private:
    char *m_pool; // 内存池起始地址
    size_t m_size; // 内存池大小
    size_t m_block_size; // 内存块大小
};

// 构造函数，对内存池进行初始化
MemoryPool::MemoryPool(size_t size, size_t block_size) : m_size(size), m_block_size(block_size) {
    m_pool = new char[m_size];

    // 对每一个内存块进行初始化
    for (size_t i = 0; i < m_size / m_block_size; ++i) {
        void *block = m_pool + i * m_block_size;
        *(char **) block = (char *)block + m_block_size;
    }
}

// 析构函数，释放内存池占用的内存
MemoryPool::~MemoryPool() {
    if (m_pool) {
        delete[] m_pool;
    }
}

第二步：新建一个内存块的管理类

接下来，我们需要设计一个内存块的管理类。该类需要记录内存块的状态，包括被占用还是未被占用，以及下一个内存块的指针。我们可以用下面的代码来实现：

class MemoryBlock {
public:
    MemoryBlock() : m_next(NULL) {}
    MemoryBlock *m_next;
};

第三步：从内存池中分配内存块

接下来，我们需要让内存池支持从预分配的内存中，进行内存块的分配和释放操作。我们可以通过将内存块看做一个链表来实现。链表的头节点指向第一个可用的内存块，在进行内存分配时，我们将头节点指向下一个未占用的内存块，并返回该内存块的地址。用下面的代码实现：

class MemoryPool {
public:
    MemoryPool(size_t size, size_t block_size);
    ~MemoryPool();
    void *alloc(size_t size);
    void free(void *ptr);
private:
    char *m_pool; // 内存池起始地址
    size_t m_size; // 内存池大小
    size_t m_block_size; // 内存块大小
    MemoryBlock *m_free_list; // 内存块可用链表头指针
};

void *MemoryPool::alloc(size_t size) {
    if (m_free_list) {
        void *block = m_free_list;
        m_free_list = m_free_list->m_next;
        return block;
    }

    // 没有可用的内存块，返回NULL
    return NULL;
}

第四步：内存块的释放

最后，我们还需要实现对内存块的释放，将被释放的内存块加入到可用链表中。对于每个释放的内存块，我们将其作为链表头，并将原链表头放在这个内存块后面。用下面的代码实现：

void MemoryPool::free(void *ptr) {
    MemoryBlock *block = (MemoryBlock *)ptr;

    // 将已释放内存块放入链表头
    block->m_next = m_free_list;
    m_free_list = block;
}

示例

示例1：测试内存池

接下来，我们利用上面的内存池实现，编写一个测试程序来测试内存池的效果：

int main() {
    size_t size = 1024 * 1024 * 10;
    size_t block_size = 128;
    MemoryPool pool(size, block_size);

    // 从内存池中分配内存
    void *ptr = pool.alloc(100);
    std::cout << ptr << std::endl;

    // 释放已分配的内存
    pool.free(ptr);

    // 再次从内存池中分配内存
    void *ptr2 = pool.alloc(100);
    std::cout << ptr2 << std::endl;
}

示例2：测试内存池的效率

为了测试内存池的效率，我们将其与直接调用operator new和operator delete的方法进行比较。我们先编写下面两个类，用于测试：

class Person {
public:
    int m_age;
    char m_name[64];
};

class Dog {
public:
    int m_age;
    char m_color[32];
};

然后，我们分别使用内存池和new / delete创建和销毁这两个类的对象，用下面的代码进行测试：

int main() {
    size_t size = 1024 * 1024 * 10;
    size_t block_size = sizeof(Person) > sizeof(Dog) ? sizeof(Person) : sizeof(Dog);
    MemoryPool pool(size, block_size);

    // 测试用内存池创建和删除Person对象
    clock_t begin_time = clock();
    for (int i = 0; i < 10000000; ++i) {
        Person *p = (Person *)pool.alloc(sizeof(Person));
        pool.free(p);
    }
    clock_t end_time = clock();
    std::cout << "Memory pool time: " << end_time - begin_time << "ms" << std::endl;

    // 测试用new和delete创建和删除Person对象
    begin_time = clock();
    for (int i = 0; i < 10000000; ++i) {
        Person *p = new Person();
        delete p;
    }
    end_time = clock();
    std::cout << "New and Delete time: " << end_time - begin_time << "ms" << std::endl;

    // 测试用内存池创建和删除Dog对象
    begin_time = clock();
    for (int i = 0; i < 10000000; ++i) {
        Dog *d = (Dog *)pool.alloc(sizeof(Dog));
        pool.free(d);
    }
    end_time = clock();
    std::cout << "Memory pool time: " << end_time - begin_time << "ms" << std::endl;

    // 测试用new和delete创建和删除Dog对象
    begin_time = clock();
    for (int i = 0; i < 10000000; ++i) {
        Dog *d = new Dog();
        delete d;
    }
    end_time = clock();
    std::cout << "New and Delete time: " << end_time - begin_time << "ms" << std::endl;

    return 0;
}

通过测试可知，使用内存池分配和释放内存的效率要比直接使用new和delete高得多。