一 简易版

1. 定义一个该类私有成员变量指针，用于串起内存池中没有使用的内存。
2. 定义一个该类静态私有成员变量指针，用于指向内存池的首地址
3. 重载 operator new 和 operator delete
4. 在 operator new 中进行内存池的建立和分配
5. 在 operator delete中进行内存的释放

代码：

#include <iostream>
using namespace std;
class A {
public:
    static void* operator new(size_t size);
    static void operator delete(void* phead);
    static size_t m_MallocCount;
    static size_t m_NewCount;
private:
    A* next;
    static A* m_FreePos;
    static size_t m_sTrunkCount;
};
A* A::m_FreePos = nullptr;
size_t A::m_sTrunkCount = 5;
size_t A::m_MallocCount = 0;
size_t A::m_NewCount = 0;
void* A::operator new(size_t size)
{
    A* tmplink = nullptr;
    if (m_FreePos == nullptr)
    {
        m_FreePos = reinterpret_cast<A*>(malloc(m_sTrunkCount*size));
        tmplink = m_FreePos;
        for (; tmplink != m_FreePos+m_sTrunkCount-1; ++tmplink)
        {
            tmplink->next = tmplink + 1;
        }
        tmplink->next = nullptr;
        m_MallocCount++;
    }
    tmplink = m_FreePos;
    m_FreePos = m_FreePos->next;
    m_NewCount++;
    return tmplink;
}
void A::operator delete(void* phead)
{
    (reinterpret_cast<A*>(phead))->next = m_FreePos;
    m_FreePos->next = reinterpret_cast<A*>(phead);
}
void function()
{
    for (int i = 0; i < 5000000; i++)
    {
        A* tmpA = new A();
    }
    cout << "malloc次数: " << A::m_MallocCount << "new次数" << A::m_NewCount << endl;
}
int main()
{
    function();
    getchar();
}

二 嵌入式指针版

1. 定义一个myallocator类进行内存的管理
2. 为了保证嵌入式指针的正常运行，需要保证myallocator的size大于等于4
3. 在myallocator类中声明一个结构体类型obj，用它的指针来管理内存
4. 在myallocator类中声明一个obj类型的指针，用于指向未分配的内存
5. 在myallocator类中声明一个size_t类型，用于表示分配的内存块大小
6. 由于代码高度重用，可以声明为宏

代码如下：

class myallocator {
public:
    void* allocator(size_t size);
    void deallocator(void* phead);
private:
    struct obj
    {
        obj* next;
    };
    size_t m_sTrunkCount = 5;
    obj* m_FreePos = nullptr;
};
void* myallocator::allocator(size_t size)
{
    obj* tmplink = nullptr;
    obj* m_FreePos = (obj*)malloc(m_sTrunkCount * size);
    tmplink = m_FreePos;
    if (m_FreePos == nullptr)
    {
        for (int i = 0; i < m_sTrunkCount - 1; i++)
        {
            tmplink->next = (obj*)((char*)tmplink + size);
            tmplink = (obj*)((char*)tmplink + size);
        }
        tmplink->next = nullptr;
    }
    tmplink = m_FreePos;
    m_FreePos = m_FreePos->next;
    return (void*)tmplink;
}
void myallocator::deallocator(void* phead)
{
    ((obj*)phead)->next = m_FreePos;
    m_FreePos = (obj*)phead;
}
#define DECLARE_POOL_ALLOC()\
public:\
    static myallocator myalloc;\
    static void *operator new(size_t size)\
    {\
        return myalloc.allocator(size);\
    }\
    static void operator delete(void *phead)\
    {\
        return myalloc.deallocator(phead);\
    }\
#define IMPLEMENT_POOL_ALLOC(classname)\
myallocator classname::myalloc;
class A
{
    DECLARE_POOL_ALLOC()
public:
    int m_i;
    int m_j; //为了保证sizeof(A)凑够4字节，老师演示时定义了两个int成员变量；    
};
IMPLEMENT_POOL_ALLOC(A)
void func()
{
    A *mypa[100];
    for (int i = 0; i < 15; ++i)
    {
        mypa[i] = new A();
        mypa[i]->m_i = 12;
        mypa[i]->m_j = 15;
        printf("%p\n", mypa[i]);
    }
    for (int i = 0; i < 15; ++i)
    {
        delete mypa[i];
    }
}