C++如何实现定长内存池详解

C++实现定长内存池的详细攻略如下：

什么是定长内存池

定长内存池是一种用于管理内存分配和释放的方法。相对于动态内存分配和释放，定长内存池可以更高效地管理内存，因为它不需要频繁地进行内存分配和释放操作，而是预先分配一块连续的内存空间，然后在此基础上进行内存管理。

定长内存池的实现方法

在C++中，我们可以使用标准库中的std::vector或者自己实现一个内存池来实现定长内存池的功能。

基于std::vector实现定长内存池

在使用std::vector来实现定长内存池时，我们需要注意以下几点：

1. 预分配内存空间。在定义std::vector对象时，我们需要通过构造函数指定预分配的内存大小，以便在程序运行时能够直接从预分配的内存空间中分配内存。

2. 实现自定义的operator new和operator delete。由于std::vector默认使用operator new和operator delete来分配和释放内存，为了实现定长内存池的功能，我们需要自己实现这两个函数，并且在std::vector对象上使用placement new和explicit destructor来构造和销毁对象。

下面是一个基于std::vector实现定长内存池的示例代码：

#include <iostream>
#include <vector>

class Object {
public:
    Object(int id) : m_id(id) {
        std::cout << "Object " << id << " is constructed." << std::endl;
    }

    ~Object() {
        std::cout << "Object " << m_id << " is destroyed." << std::endl;
    }

    void *operator new(size_t size, void *p) {
        return p;
    }

    void operator delete(void *p) {
        // do nothing
    }

private:
    int m_id;
};

class MemoryPool {
public:
    MemoryPool(size_t size, size_t objectSize) {
        m_data.resize(size);
        m_objectSize = objectSize;
    }

    void *allocate() {
        if (m_freeList.empty()) {
            if (m_data.size() < m_objectSize) {
                return nullptr;
            }

            m_freeList.reserve(m_data.size() / m_objectSize);
            for (size_t i = 0; i < m_data.size(); i += m_objectSize) {
                m_freeList.push_back(&m_data[i]);
            }
        }

        void *p = m_freeList.back();
        m_freeList.pop_back();
        return p;
    }

    void deallocate(void *p) {
        m_freeList.push_back(p);
    }

private:
    std::vector<char> m_data;
    size_t m_objectSize;

    std::vector<void *> m_freeList;
};

int main() {
    MemoryPool pool(1024, sizeof(Object));

    Object *obj1 = new(pool.allocate()) Object(1);
    Object *obj2 = new(pool.allocate()) Object(2);

    obj1->~Object();
    pool.deallocate(obj1);

    obj2->~Object();
    pool.deallocate(obj2);

    return 0;
}

在这个示例代码中，我们首先定义了一个Object类，它有一个私有变量m_id，用于标识对象。我们还实现了自定义的operator new和operator delete，并且在构造和销毁对象时打印出相关信息。

然后我们定义了一个MemoryPool类，它包含一个std::vector对象m_data，用于保存预分配的内存空间；一个m_objectSize变量，用于记录每个对象的大小；和一个m_freeList向量，用于保存可用的内存指针。

在allocate函数中，我们首先判断m_freeList向量中是否有可用的内存指针。如果没有，我们就循环遍历预分配的内存空间，每次将一个对象的指针加入到m_freeList向量中。在循环结束后，m_freeList向量中就保存了所有可用的内存指针。

在每次分配内存时，我们从m_freeList向量的末尾取出一个指针，然后将它从m_freeList向量中删除，即可获得可用的内存空间。在释放内存时，我们将它加入到m_freeList向量的末尾，等待下一次分配。

最后，我们在main函数中使用MemoryPool类来分配和释放内存空间，并且在构造和销毁对象时打印出相关信息。在实际使用中，我们可以将MemoryPool类封装成一个单例类或者静态类，以便程序的全局使用。

基于自己实现内存池实现定长内存池

除了使用std::vector之外，我们还可以自己实现一个内存池来实现定长内存池的功能。在自己实现内存池时，我们需要注意以下几点：

1. 实现内存分配和释放。我们可以使用链表或者向量来管理空闲的内存块。在分配内存时，我们从空闲内存列表中取出一个内存块，并将其从列表中删除；在释放内存时，我们将内存块加入到空闲内存列表中。为了避免内存碎片，最好将相邻的空闲内存块合并。

2. 处理内存对齐。在定义对象时，我们需要将其按照特定的字节对齐方式进行对齐，以保证内存池的正确运行。在分配内存时，我们也需要按照相同的字节对齐方式进行内存分配，以保证对象的正确创建和访问。

下面是一个基于自己实现内存池的示例代码：

#include <iostream>
#include <cstring>

class Object {
public:
    Object(int id) : m_id(id) {
        std::cout << "Object " << id << " is constructed." << std::endl;
    }

    ~Object() {
        std::cout << "Object " << m_id << " is destroyed." << std::endl;
    }

    void *operator new(size_t size, void *p) {
        return p;
    }

    void operator delete(void *p) {
        // do nothing
    }

private:
    int m_id;
};

class MemoryPool {
public:
    MemoryPool(size_t size, size_t objectSize, size_t objectAlign) {
        m_data = new char[size];
        m_poolSize = size;
        m_objectSize = objectSize;
        m_objectAlign = objectAlign;

        // align initial memory block
        size_t adjustment = alignPtr(m_data, m_objectAlign);
        m_freeList = (FreeList *)m_data;

        char *prev = m_data;
        char *curr = prev + adjustment;
        while (curr + m_objectSize <= m_data + m_poolSize) {
            ((FreeList *)prev)->next = (FreeList *)curr;
            prev = curr;
            curr += m_objectSize;
        }
        ((FreeList *)prev)->next = nullptr;
    }

    ~MemoryPool() {
        delete[] m_data;
    }

    void *allocate(size_t size) {
        if (size != m_objectSize) {
            return nullptr;
        }

        FreeList *p = m_freeList;
        if (p == nullptr) {
            return nullptr;
        }
        m_freeList = p->next;

        return p;
    }

    void deallocate(void *p) {
        ((FreeList *)p)->next = m_freeList;
        m_freeList = (FreeList *)p;
    }

private:
    struct FreeList {
        struct FreeList *next;
    };

    void *m_data;
    size_t m_poolSize;
    size_t m_objectSize;
    size_t m_objectAlign;

    FreeList *m_freeList;

    static size_t alignPtr(const void *p, size_t align) {
        uintptr_t addr = reinterpret_cast<uintptr_t>(p);
        return align - (addr % align);
    }

};

int main() {
    MemoryPool pool(1024, sizeof(Object), alignof(Object));

    Object *obj1 = new(pool.allocate(sizeof(Object))) Object(1);
    Object *obj2 = new(pool.allocate(sizeof(Object))) Object(2);

    obj1->~Object();
    pool.deallocate(obj1);

    obj2->~Object();
    pool.deallocate(obj2);

    return 0;
}

在这个示例代码中，我们首先定义了一个Object类，它有一个私有变量m_id，用于标识对象。我们还实现了自定义的operator new和operator delete，并且在构造和销毁对象时打印出相关信息。

然后我们定义了一个MemoryPool类，它包含了一个指向预分配内存区域的指针m_data，一个记录内存池大小的变量m_poolSize，一个记录对象大小的变量m_objectSize，一个记录对象对齐方式的变量m_objectAlign，以及一个指向空闲内存链表的指针m_freeList。

在MemoryPool类的构造函数中，我们首先对内存块进行字节对齐，然后将其进行建表，建立空闲内存链表。在allocate函数中，我们从空闲内存链表中取出一个内存块，并将其从链表中删除，以进行分配。在deallocate函数中，我们将释放的内存块添加到空闲内存链表中。

最后，我们在main函数中使用MemoryPool类来分配和释放内存空间，并且在构造和销毁对象时打印出相关信息。同样的，在实际使用中，我们可以将MemoryPool类封装成一个单例类或者静态类，以便程序的全局使用。