求助：C++内存池Mempool问题

先附代码：
MemoryBlock.h
#pragma once
#include
#include
using namespace std;

struct MemoryBlock
{
USHORT nSize;//可分配内存总大小
USHORT nFree;//可分配内存单元数目
USHORT nFirst;//第一个可用的内存单元位置
MemoryBlock* pNext;//指向下一个内存块
char aData[1];

static void* operator new(size_t, USHORT nTypes, USHORT nUnitSize)
{
   return ::operator new(sizeof(MemoryBlock) + nTypes * nUnitSize);//申请一个内存块空间
}
static void  operator delete(void *p, size_t)
{
    ::operator delete (p);//删除内存块空间
}

MemoryBlock(USHORT nTypes = 1, USHORT nUnitSize = 0);
~MemoryBlock() {}

};

MemoryBlock::MemoryBlock(USHORT nTypes, USHORT nUnitSize)
: nSize(nTypes * nUnitSize),
nFree(nTypes - 1),
nFirst(1),
pNext(0)
{
char * pData = aData;
for (USHORT i = 1; i < nTypes; i++)//初始化1到nTypes-1的指向
{
reinterpret_cast<USHORT>(pData) = i;
pData += nUnitSize;
}
}

MemoryPool.h
#pragma once
#include
#include
#include"MemoryBlock.h"
using namespace std;

class MemoryPool
{
private:
MemoryBlock * pBlock;//指向第一个内存块
USHORT nUnitSize;//一个可分配单元的大小
USHORT nInitSize;//第一个内存块可分配空间数目
USHORT nGrowSize;//后续申请的内存块的可分配空间数目

public:
MemoryPool(USHORT nUnitSize,
USHORT nInitSize = 1024,
USHORT nGrowSize = 256);//单元大小，第一个内存块的可分配空间数目，第二个内存块之后的可分配空间数目（可设置）
~MemoryPool();

void*           Alloc();//分配内存 
void            Free(void* pfree);//回收内存 
void FreeMemoryBlock(MemoryBlock *pblock);//销毁

};

MemoryPool.cpp
#include"MemoryPool.h"

const USHORT MEMPOOL_ALIGNMENT = 2;

MemoryPool::MemoryPool(USHORT _nUnitSize,
USHORT _nInitSize, USHORT _nGrowSize)
{
pBlock = NULL;

nInitSize = _nInitSize;

nGrowSize = _nGrowSize;

    if (_nUnitSize > 4)
        nUnitSize = (_nUnitSize + (MEMPOOL_ALIGNMENT - 1)) & ~(MEMPOOL_ALIGNMENT - 1); //将大于4个字节的大小_nUnitSize往上"取整到"大于_nUnitSize的最小的MEMPOOL_ ALIGNMENT的倍数
    else if (_nUnitSize <= 2)
        nUnitSize = 2;              
    else
        nUnitSize = 4;

}

void* MemoryPool::Alloc()
{
if (!pBlock)//如果是第一次申请

{
MemoryBlock* pmb_first = new (nInitSize, nUnitSize)MemoryBlock(nInitSize, nUnitSize);
pBlock = pmb_first;
return (void*)pmb_first->aData;
}

MemoryBlock* pMyBlock = pBlock;
while (pMyBlock && !pMyBlock->nFree)//pMyBlock没走到最后并且当前内存块没有可分配结点
{
    pMyBlock = pMyBlock->pNext;//往之后的内存块遍历
}

if (pMyBlock)//如果找到可分配结点的内存块     
{
    char* pFree = pMyBlock->aData + (pMyBlock->nFirst*nUnitSize);
    pMyBlock->nFirst = *((USHORT*)pFree);
    pMyBlock->nFree--;//可分配节点自减 
    return (void*)pFree;
}
else//如果找不到,此时pMyBlock值为0 
{
    if (!nGrowSize)
        return NULL;

    pMyBlock = new(nGrowSize, nUnitSize) MemoryBlock(nGrowSize, nUnitSize);
    if (!pMyBlock)//创建不成功
        return NULL;

    pMyBlock->pNext = pBlock;//把新建的block放到最前
    pBlock = pMyBlock;

    return (void*)(pMyBlock->aData);
}

}

void MemoryPool::Free(void* pfree)
{
if (pBlock == NULL)
return;
MemoryBlock* pmb_block = pBlock;
MemoryBlock* pmb_preblock = pBlock;
while ((ULONG)pfree<(ULONG)pmb_block->aData ||
(ULONG)pfree>(ULONG)(pmb_block->aData + pmb_block->nSize))//pfree不在当前block中
{
pmb_preblock = pmb_block;//前一个block块
pmb_block = pmb_block->pNext;
if (!pmb_block)
return;
}
pmb_block->nFree++;//可分配数目+1
((USHORT)pfree) = pmb_block->nFirst;
pmb_block->nFirst = (USHORT)((ULONG)pfree - (ULONG)pmb_block->aData) / nUnitSize;
if (pmb_block->nFree*nUnitSize == pmb_block->nSize)//如何该链块为空
{
pmb_preblock->pNext = pmb_block->pNext;
if ((ULONG)pmb_preblock == (ULONG)pBlock)
pBlock = NULL;
delete pmb_block;
}
}

MemoryPool::~MemoryPool(void)
{
if (pBlock)
FreeMemoryBlock(pBlock);
}

void MemoryPool::FreeMemoryBlock(MemoryBlock *pblock)
{
if (pblock->pNext)
FreeMemoryBlock(pblock->pNext);
delete pblock;
pblock = NULL;
}

请问：如何将信息存入内存池，如何从内存池中取出已存入的信息，信息可以是string类或是自己定义的类吗？

https://blog.csdn.net/chexlong/article/details/7071922

https://blog.csdn.net/u012778714/article/details/80299475

内存池是用来管理内存的，当下流行的技术是引用计数或者垃圾回收机制。
你的数据如何使用内存池，这依赖于你的内存池支持哪种数据结构，或者说去重载new/delete

内存池的构建，要拥有边界处理的能力，数据溢出处理，内存碎片处理，内存使用率优化处理。
同时搭配对象池来使用，味道更鲜美哦！

你代码中并未封装实用的数据结构，所以如果你要用string 或者自定义类型，需要题主自己封装一下数据结构，vector,array,map,set 等，根据你的需要来封装，
注意你的数据结构中管理的数据，要全部出自于你的内存池，这样内存池的存在才有意义。