C++ 較爲完善的內存池

引用於：https://www.cnblogs.com/geekpaul/p/4204124.html
做了一點小修改

1.內存的分配：
（1）如果分配大小超過1024，直接採用malloc分配，分配的時候多分配sizeof(size_t)字節，用於保存該塊的大小；
（2）否則根據分配大小，查找到容納該大小的最小size的MemoryChunk；
（3）查找MemoryChunk的鏈表指針pList，找到空閒的MemoryBlock返回；
（4）如果pList爲NULL，臨時創建MemoryBlock返回；
（5）MemoryBlock頭部包含兩個成員，pChunk指向的所屬的MemoryChunk對象，size表明大小，其後纔是給用戶使用的空間；
2.內存的釋放：
（1）根據釋放的指針，查找器size頭部，即減去sizeof(size_t)字節，判斷該塊的大小；
（2）如果大小超過1024，直接free;
（3）否則交給MemoryChunk處理，而塊的頭部保存了該指針，因此直接利用該指針就可以收回該內存。
注意的問題：
　　上述設計的內存池通過冗餘的頭部來實現內存塊的分配與釋放，減少了內存池的操作時間，速度上要優於原始的malloc和free操作，同時減少了內存碎片的增加。但是該設計中沒有去驗證釋放的塊冗餘頭部的正確性，因此故意釋放不屬於內存池中的塊或者修改頭部信息都會導致內存池操作失敗，當然這些可以由程序員來控制。此外，內存池中分配出去的內存塊如果不主動釋放，內存池沒有保留信息，不會自動釋放，但是在退出的時候會驗證驗證是否完全釋放，其實這個在系統測試時候就可以檢測出來，我想這個缺陷也是可以彌補的，在此提出，希望使用者注意。

#include <bits/stdc++.h>
using namespace std;
#include <pthread.h>
typedef pthread_mutex_t MUTEXTYPE;
#define INITMUTEX(hMutex) pthread_mutex_init(&hMutex,nullptr)
#define DELMUTEX(hMutex) pthread_mutex_destroy(&hMutex)
#define LOCK(hMutex) pthread_mutex_lock(&hMutex)
#define UNLOCK(hMutex) pthread_mutex_unlock(&hMutex)

class MemoryChunk;
struct BlockHeader
{
    MemoryChunk* pChunk;
    size_t len; // data size or free mem
};
struct MemoryBlock;
struct BlockData
{
    union{
        MemoryBlock* pNext;
        char *pBuffer;
    };
};
struct MemoryBlock
{
    BlockHeader header;
    BlockData data;
};
class MemoryChunk
{
public:
    MemoryChunk(size_t size, int count)
    {
        INITMUTEX(hMutex);
        this->pFreeList=nullptr;
        this->size=size;
        this->count=0;
        MemoryBlock* pBlock;
        while(count--){
            pBlock=CreateBlock();
            if(!pBlock)break;
            pBlock->data.pNext=pFreeList;
            pFreeList=pBlock;
        }
    }
    ~MemoryChunk()
    {
        int tempcount=0;
        MemoryBlock* pBlock;
        pBlock = pFreeList;
        while(pBlock){
            pFreeList=pBlock->data.pNext;
            DeleteBlock(pBlock);
            ++tempcount;
            pBlock = pFreeList;
        }
        assert(tempcount==count);//!確保釋放完全
        DELMUTEX(hMutex);
    }
    void* malloc()
    {
        MemoryBlock* pBlock;
        LOCK(hMutex);
        if(pFreeList){
            pBlock=pFreeList;
            pFreeList=pBlock->data.pNext;
        }else{
            if(!(pBlock=CreateBlock())){
                UNLOCK(hMutex);
                return nullptr;
            }
        }
        UNLOCK(hMutex);
        return &pBlock->data.pBuffer;
    }
    static void free(void* pMem)
    {
        auto* pBlock=(MemoryBlock*)((char*)pMem-sizeof(BlockHeader));
        pBlock->header.pChunk->free(pBlock);
    }
    void free(MemoryBlock* pBlock)
    {
        LOCK(hMutex);
        pBlock->data.pNext=pFreeList;
        pFreeList=pBlock;
        UNLOCK(hMutex);
    }
protected:
    MemoryBlock* CreateBlock()
    {
        auto* pBlock=(MemoryBlock*)::malloc(sizeof(BlockHeader)+size);
        if(pBlock){
            pBlock->header.pChunk=this;
            pBlock->header.len=size;
            ++count;
        }
        return pBlock;
    }
    void DeleteBlock(MemoryBlock* pBlock)
    {
        ::free(pBlock);
    }
private:
    MemoryBlock* pFreeList;
    size_t size;//!Block大小
    int count;//!Block數目
    MemoryChunk* pNext{};
    MUTEXTYPE hMutex{};
};

struct HeapHeader
{
    size_t size;
};
struct MemoryHeap
{
    HeapHeader header;
    char pBuffer;
};

class StaticMemory
{
public:
    typedef enum{MAX_SIZE=1024,MIN_SIZE=sizeof(MemoryChunk*)};
    StaticMemory()
    {
        chunkcount=0; // 類似 stl 二級管理
        for(size_t size=MIN_SIZE; size<=MAX_SIZE; size*=2)++chunkcount;
        pChunkList=new MemoryChunk*[chunkcount];
        int index=0;
        for(size_t size=MIN_SIZE; size<=MAX_SIZE; size*=2)
        {
            pChunkList[index++]=new MemoryChunk(size,1000);
        }
    }
    ~StaticMemory()
    {
        for(int index=0; index<chunkcount; ++index)
        {
            delete pChunkList[index];
        }
        //free(pChunkList);
        delete[] pChunkList;
    }
    void* Malloc(size_t size)
    {
        if(size>MAX_SIZE){
            return malloc(size);
        }
        int index=0; // 找到最接近的那一塊
        for(size_t tsize=MIN_SIZE; tsize<=MAX_SIZE; tsize*=2){
            if(tsize>=size)break;
            ++index;
        }
        return pChunkList[index]->malloc();
    }
    void Free(void* pMem)
    {
        if(!free(pMem))MemoryChunk::free(pMem);
    }
protected:
    void* malloc(size_t size)
    {
        auto* pHeap=(MemoryHeap*)::malloc(sizeof(HeapHeader)+size);
        if(pHeap){
            pHeap->header.size=size;
            return &pHeap->pBuffer;
        }
        return nullptr;
    }
    bool free(void* pMem)
    {
        auto* pHeap=(MemoryHeap*)((char*)pMem-sizeof(HeapHeader));
        if(pHeap->header.size>MAX_SIZE){
            ::free(pHeap);
            return true;
        }
        return false;
    }
private:
    MemoryChunk** pChunkList;
    int chunkcount;
};

int main(){
    StaticMemory st;

    int *m1 = (int *)st.Malloc(12);
    int *m2 = (int *)st.Malloc(4);
    int *m3 = (int *)st.Malloc(4);
    *m1=1;
    *m2=2;
    *m3=3;
    cout<< *m1<<endl;
    st.Free(m1);
    st.Free(m2);
    st.Free(m3);
}