C++内存池memorypool的使用

程序：

#include<iostream>
using namespace std;
#define size 4
#define maxsize 10

struct freenode//空间节点结构体
{
    char data[size];//分配给对象的空间大小
    //一个类多少个字节，size就可以多大   
   // struct freenode *next;

    struct obj
    {
        struct obj*next; //嵌入式指针，只有指针，没有确切的值，没有生成额外的空间
    }; 
};

struct memblock//内存块结构体
{
    freenode data[maxsize];//一个内存块有十个节点的内存
    memblock *next;
};

class memorypool//内存池
{
    public:

        memorypool()
        {
            blockhead = NULL;
            nodehead = NULL;
        }

        ~memorypool()
        {
            while(blockhead != NULL)
            {
                memblock * ptr = blockhead->next;
                delete blockhead;//blockhead是头结点
                blockhead = ptr;//blockhead是头指针
                cout<<"调用析构函数"<<endl;

            }
        }

        void *malloc();//空间申请
        void free(void * p);//空间释放

    private:

        memblock *blockhead;//内存块的头指针
        freenode * nodehead;//空闲节点头指针
};

void *memorypool::malloc()
{
    if(nodehead == NULL)
    {
        freenode::obj *ptemp;//临时的嵌入式指针
        memblock * newblock = new memblock;//申请新的内存块
        newblock->next = NULL;
        nodehead = &newblock->data[0];//将内存块的节点数组的第一个节点给到nodehead
        //空闲节点的头指针指向
        
        ptemp = (freenode::obj*)nodehead;  //借空间，强制类型转换

        for(int i = 1; i < maxsize; i++)//将每个空闲节点连接起来
        {
            //newblock->data[i-1].next = &newblock->data[i];//把前一个节点指针的next指向当前节点
            ptemp->next =(freenode::obj *) &newblock->data[i];//数组元素的第二个首地址
        }

        //newblock->data[maxsize - 1].next = NULL;//最后一个节点的next指向空
        ptemp->next = NULL;

        if(blockhead == NULL)
        {
            blockhead = newblock;//当前申请的内存块为内存池的第一块内存
        }
        else
        {
            newblock->next = blockhead;
            blockhead = newblock;//头插法
        }
    }
 
    else
    {
        void * freenode1 = nodehead;   //freenode *转为 void *,为强制类型转换
        //把空闲节点链表的第一个节点输出
        //nodehead = nodehead->next;//节点往后走一个
        freenode::obj *ptemp = (freenode::obj*)nodehead;
        ptemp = ptemp->next;
        nodehead = (freenode *)ptemp;
        return freenode1; 
    }
    

}

void memorypool::free(void *p)
{
    freenode * ptr = static_cast<freenode *>(p);   //指针类型转换

    for(int i = 0; i < size; i++)       //空间的清空
    {
        ptr->data[i] = 0;
    }

    //ptr->next = nodehead;
    freenode::obj * ptemp = (freenode ::obj*)ptr;
    ptemp->next = (freenode::obj*)nodehead;
    nodehead = ptr;//头插法
    cout<<"1"<<endl;
}

memorypool mp;//全局变量

class A
{
    public:

        A()
        {
            cout<<"创建一个对象"<<endl;
        }

        void * operator new(size_t size1)//重载new,使用内存值提供的内存
        {
            cout<<"使用内存池申请空间"<<endl;
            return mp.malloc();
        }

        void operator delete(void *p)
        {
            mp.free(p);     //使用内存池释放方式，把这块内存重新还到内存池里
            cout<<"使用内存池释放方式"<<endl;
        }

    private:

        int m_a;
};

int main()
{
    A *p1 = new A;
    A *p2 = new A;
    //A *p3 = new A;
    //A *p4 = new A;

    delete(p1);
    delete(p2);
    // delete(p3);
    // delete(p4);

    return 0;
    //内存池好智能哦，自动灵活运用内存空间
    //需要手写new和delete
}

终端：

使用内存池申请空间
创建一个对象
使用内存池申请空间
创建一个对象
1
使用内存池释放方式
1
使用内存池释放方式