[C++知识库]C++-对象池

首先我们知道

class Node
{
    
public:
    //struct Obj { Obj* next; };
    int a;//4
    char b;//1
};

他的内存大小是8 如果此时添加 struct Obj { Obj* next; };也就是把那个注释取消
会发现还是八个字节 并没有多占用内存

对象池是什么

就是提前分配好例如一千个类对象 然后在需要的时候从这一千个对象中分配对象出去

定义对象池的目的是什么

一个是防止内存碎片化 直接分配一块足够大的内存 然后里面都是连续的对象 就不会需要的时候再找地方分配了
第二个是节约cookie 因为从内存那知道 我们没吃申请一个地址 地址的开头和结尾处都有额外的cookie 这样会浪费内存 所有我们如果使用对象池 就可以节约这一块内存

代码实现

#define N 1000
struct LinkedPointer {//保存他申请的所有内存块
    void* ptr;
    LinkedPointer* next;
};
class Node
{
    
public:
    struct Obj { Obj* next; };
    static Obj* Header;//作为对象池的头结点 因为整个对象池只需要一个头 所以声明为静态的
    static LinkedPointer* linkedPtr;//存储这块大内存的起始地址
    static int mallocCount;//用来记录分配了多少个对象了
private:
    int a;//4
    char b;//1
    static void* operator new(size_t size)
    {
        if (nullptr == Header)//如果还没有创建头结点 那么我们就开辟一个可以容纳1000个对象的内存
        {
            /*如果对象全部分配出去了 且都没归还 则调全局的new 不从对象池分配内存了*/
            if (mallocCount >= 1)
            {
                return ::operator new(size);
            }
            size_t total = size * N;
            void* temp = malloc(total);//temp目前是这块内存的头指针
            mallocCount++;//每次分配都+1 如果数量到达1000则说明分配完了 
            /*分配完之后就让头指针指向这个地址的首地址*/
            Header = (Obj*)temp;

            Obj* tempitem = Header;
            /*对地址进行分割 也是把这一串分配的内存串起来 就像链表一样*/
            for (int i = 1; i < N; i++)
            {
                void* ptr = (char*)tempitem + size;//让这个指针指向第二个对象起始地址
                tempitem->next = (Obj*)ptr;
                tempitem = tempitem->next;
            }
            tempitem->next = nullptr;//防止最后一个指针指到别人的内存上去

            /*但是这个貌似只执行一次啊 没弄懂 应该是只获取这块大内存的起始地址*/
            LinkedPointer* linkPtr = new LinkedPointer();
            linkPtr->ptr = temp;
            if (linkedPtr = nullptr)
            {
                linkedPtr = linkPtr;
            }
            else
            {
                linkedPtr->next = linkPtr;
            }
        }
        void* Ret = Header;//每次我们就把头结点分配出去
        Header = Header->next;//指向下一个结点 方便下一次分配
        return Ret;
    }
    static void operator delete(void* p, size_t size)
    {
        /*先判断这个对象是不是你的对象 如果不是你的 就调用全局的释放函数*/
        if (!IsValidPtr(p))
        {
            ::operator delete(p);
        }
        if (nullptr == Header)
        {
            Header = (Obj*)p;
        }
        /*如果是你的对象池的对象 则把这个释放的对象作为你的链表头 也就是放回来了*/
        ((Obj*)p)->next = Header;
        Header = (Obj*)p;
    }
    /*用来判断归还的这个对象是不是我们对象池里面的对象 也就是我们最开始我们只存了1000个对象在对象池里面 
    如果我们使用了超过一千个就会分配不是对象池里面的对象 或者属于对象池的对象没有归还回对象池*/
    static bool IsValidPtr(void* ptr)
    {
        /*也就是用来判断归还的这一块内存是不是在这块大的内存里面*/
        if (linkedPtr->ptr >= ptr && ptr < (((char*)linkedPtr->ptr)+8000))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

};
Node::Obj* Node::Header = nullptr;//在类外对静态变量进行初始化
LinkedPointer* Node::linkedPtr = nullptr;
int Node::mallocCount =  0;

这个上面我们就已经完成了一个初步的对象池