c++ 实现内存池

内存池预先分配一块连续的内存，可以有效减少内存碎片，记录一下

MemoryPool.h

#pragma once

class MemoryPool
{
public:
	static MemoryPool* create(int nCount, int nSize);	//创建内存池的大小
	static void destory(MemoryPool* pMemoryPool);		//销毁内存池

	void* allocCache(int nSize);	//创建内存
	void freeCache(void* pData);	//释放内存

private:
	MemoryPool();
	~MemoryPool();
	void init(int nCount, int nSize);

	struct MemoryNode				//链表，存放地址
	{
		MemoryNode* pNext;
	};
	MemoryNode* m_pCurrNode;		//当前节点
	void* m_pBegin;					//开始指针
	int m_nNodeSize;				//节点大小
	int m_nNodeCount;				//节点个数
};

MemoryPool.cpp

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "MemoryPool.h"

MemoryPool* MemoryPool::create(int nCount, int nSize)
{
	MemoryPool* pMemoryPool = new MemoryPool();
	pMemoryPool->init(nCount, nSize);
	return pMemoryPool;
}

void MemoryPool::destory(MemoryPool* pMemoryPool)
{
	if (pMemoryPool)
		delete pMemoryPool;
}

MemoryPool::MemoryPool()
: m_pCurrNode(nullptr)
, m_pBegin(nullptr)
, m_nNodeSize(0)
{

}

MemoryPool::~MemoryPool()
{
	if (m_pBegin){
		free(m_pBegin);
		m_pBegin = nullptr;
	}
	m_pCurrNode = nullptr; 
}

void MemoryPool::init(int nCount, int nSize)
{
	int nMinSize = sizeof(MemoryNode);
	if (nSize < nMinSize)
		nSize = nMinSize;
	m_nNodeSize = nSize;
	m_nNodeCount = nCount;

	m_pBegin = malloc(nCount * nSize);
	for (int i = 0; i < nCount; ++i)
	{
		MemoryNode* pCur = (MemoryNode*)((char*)m_pBegin + i*nSize);
		pCur->pNext = m_pCurrNode;
		m_pCurrNode = pCur;
	}
}

void* MemoryPool::allocCache(int nSize)
{
	if (m_pCurrNode && m_nNodeSize >= nSize)
	{
		MemoryNode* pData = m_pCurrNode;
		m_pCurrNode = m_pCurrNode->pNext;
		return pData;
	}
	return malloc(nSize);
}

void MemoryPool::freeCache(void* pData)
{
	if (!pData)
		return;

	if (pData >= m_pBegin && pData < (char*)m_pBegin + m_nNodeSize*m_nNodeCount){
		//在内存池范围内,添加链表里
		MemoryNode* pNode = (MemoryNode*)pData;
		pNode->pNext = m_pCurrNode;
		m_pCurrNode = pNode;
		return;
	}

	free(pData);
}

使用方法：main.cpp

struct TempNode
{
	int nNum1;
};

int main(int argc, char** argv){

	MemoryPool* pMemoryPool = MemoryPool::create(100, sizeof(TempNode));

	TempNode* pNode = (TempNode*)pMemoryPool->allocCache(sizeof(TempNode));
	pNode->nNum1 = 1;

	pMemoryPool->freeCache(pNode);

	MemoryPool::destory(pMemoryPool);

	return 1;
}