C++实现内存池

最新推荐文章于 2024-08-02 07:00:00 发布
最新推荐文章于 2024-08-02 07:00:00 发布
阅读量182 收藏 1
点赞数
文章标签： C++ 内存池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012398164/article/details/102988213
版权
本文档详细介绍了如何在C++中实现内存池，包括MemoryPool.cpp中的MemoryBlock结构和相关实现，以及如何在main.cpp中有效使用内存池。通过这种方式，可以优化内存分配和释放的效率，提高程序性能。
摘要由CSDN通过智能技术生成

C++实现内存池


参考：https://www.cnblogs.com/dylantsou/archive/2012/05/13/2498491.html
详细原理可以上面的链接。
内存池是由block链表实现，每个block（块）链表上挂载了多个unit （单元）。
本人在链接基础上封装了block 成员变量。并且block 中的unit 采用链表方式，一个unit 指向 下一个可用的unit。优化了内存越界bug。干掉了对USHORT 的依赖。
使用起来更加优雅，简洁，明了
内存池：
MemoryPool.h 

#pragma once
#include <stdlib.h>
#include "MemoryBlock.h"

class MemoryPool
{
public:
	//_unitCount 每个block下 unit个数
	MemoryPool(int _unitSize, int _unitCount = 16);
	~MemoryPool();

	void *Alloc();
	void Free(void *);

private:
	int				unitSize;	//单元大小
	int				unitCount;	//多少个单元

	MemoryBlock*	pBlock;		//内存链表
};

MemoryPool.cpp:

#include "MemoryPool.h"
#define  MEMPOOL_ALIGNMENT 8            //对齐长度

#include <stdio.h>
#include <iostream>

MemoryPool::MemoryPool(int _unitSize, int _unitCount)
{
	unitSize = _unitSize;
	unitCount = _unitCount;

	pBlock = NULL;
	if (unitSize > 4)
		unitSize = (unitSize + (MEMPOOL_ALIGNMENT - 1)) & ~(MEMPOOL_ALIGNMENT - 1);
	else if (unitSize < 2)
		unitSize = 2;
	else
		unitSize = 4;
}

MemoryPool::~MemoryPool()
{
	MemoryBlock *p = pBlock;
	MemoryBlock *temp;
	while (p)
	{
		temp = p;
		p = p->pNext;
		delete temp;
	}
}

void * MemoryPool::Alloc()
{
	//第一次为空，分配第一个block
	if (pBlock == NULL)
	{
		std::cout << "first new block " << std::endl;
		pBlock = (MemoryBlock *)new(unitSize, unitCount) MemoryBlock(unitSize, unitCount);
		if (pBlock == NULL)
		{
			std::cout << "error new block failed" << std::endl;
			return NULL;
		}
		return pBlock->mallocUnit();
	}

	//找到第一个 有空闲的 block
	MemoryBlock *tempBlock = pBlock;
	while (tempBlock && tempBlock->memFull())
	{
		tempBlock = tempBlock->pNext;
	}

	//若 没有空闲block，再次分配一个block
	if (tempBlock == NULL)
	{
		std::cout << "next new block " << std::endl;
		tempBlock = (MemoryBlock *)new(unitSize, unitCount) MemoryBlock(unitSize, unitCount);
		if (tempBlock == NULL)
		{
			std::cout << "error new block failed" << std::endl;
			return NULL;
		}

		tempBlock->pNext = pBlock;
		pBlock = tempBlock;
	}
	
	return tempBlock->mallocUnit();
}

void MemoryPool::Free(void * pFree)
{
	MemoryBlock * tempBlock = pBlock;
	MemoryBlock * preBlock = tempBlock;

	while (tempBlock != NULL && !tempBlock->inBlock(pFree))
	{
		preBlock = tempBlock;
		tempBlock = tempBlock->pNext;
	}

	if (tempBlock == NULL)
	{
		printf("Errror cannot find mem \n");
		return;
	}

	printf("free mem ok\n");
	tempBlock->freeUnit(pFree);

	// 若整个block都是空闲，则回收这个block
	if (tempBlock->memEmpty())
	{
		if (tempBlock == pBlock)
		{
			pBlock = pBlock->pNext;
		}
		else
		{
			preBlock->pNext = tempBlock->pNext;
		}

		printf("delete block \n");
		delete tempBlock;
	}
	else //将此block 放置到链表首
	{
		if (tempBlock = pBlock)
		{
			return;
		}

		preBlock->pNext = tempBlock->pNext;
		tempBlock->pNext = pBlock;
		pBlock = tempBlock;
	}
}

block实现：
MemoryBlock.h

#pragma once

#include <stdlib.h>

class MemoryBlock
{
public:
	MemoryBlock(int _nUnitSize, int _unitCount);
	~MemoryBlock();

	static void *  operator new(size_t, int nUnitSize, int nUnitAmount);
	static void    operator delete(void *, int nUnitSize, int nUnitAmount){}
	static void    operator delete(void *pBlock);

public:
	void *mallocUnit();
	bool freeUnit(void *pFree);

	//是否所有单元装满了
	bool memFull() { return nFree == 0; }

	//是否所有单元为空
	bool memEmpty();

	bool inBlock(void *pFree);

	MemoryBlock*	pNext;		//下一个block

private:
	int				unitSize;	//单元大小
	int				unitCount;	//单元数量
	int				totalSize;		// 该块内存大小， 字节
	int				nFree;		// 多少个单元
	void *			nextPtr;	// 当前可用单元 地址
	char			aData[1];	// 分配单元起始位置
};

MemoryBlock.cpp

#include "MemoryBlock.h"
#include <iostream>

//区分32位和64位
#ifdef _WIN64 
#define PTR_TYPE unsigned long long
#else
#define PTR_TYPE unsigned long
#endif

//将 h 前几个字节存放 下一个指针的值 
static void setNextUnitPointer(void *h, void *pNextUnit)
{
	*(PTR_TYPE *)(h) = (PTR_TYPE)(pNextUnit);
}

//取出 h 指针内存放的 下一指针值
static void getNextUnitPointer(void *h, void **pNextUnit)
{
	*pNextUnit = (void *) (*(PTR_TYPE *)(h));
}

MemoryBlock::MemoryBlock(int _nUnitSize, int _unitCount)
	: unitSize(_nUnitSize)
	, unitCount(_unitCount)
	, totalSize(unitCount * unitSize)
	, nFree(unitCount)
	, pNext(NULL)
{
	nextPtr = (void *)aData;
	char *ptr = aData;

	// 每个单元前几个字节存放下一个单元的地址， 其实是一个链表
	for (int i = 0; i < unitCount - 1; i++)
	{
		setNextUnitPointer(ptr + i*unitSize, ptr + i * unitSize + unitSize);
	}
}

MemoryBlock::~MemoryBlock()
{
}

void *  MemoryBlock::operator new(size_t, int nUnitSize, int unitCount)
{
	return ::operator new(sizeof(MemoryBlock) + nUnitSize * unitCount);
}

void    MemoryBlock::operator delete(void *pBlock)
{
	::operator delete(pBlock);
}

void * MemoryBlock::mallocUnit()
{
	void *pFree = nextPtr;

	getNextUnitPointer(nextPtr, &nextPtr);
	nFree--;

	std::cout << "new unit , free =  " << nFree << std::endl;
	return pFree;
}

bool MemoryBlock::freeUnit(void *pFree)
{
	setNextUnitPointer(pFree, nextPtr);
	nextPtr = pFree;

	nFree++;
	return true;
}

bool MemoryBlock::memEmpty()
{
	return (totalSize == nFree * unitSize);
}

bool MemoryBlock::inBlock(void *pFree)
{
	return pFree >= aData  &&  pFree <= aData + totalSize;
}

如何使用：
main.cpp


#include <stdio.h>
#include "MemoryBlock.h"
#include "MemoryPool.h"

class CTest
{
public:
	CTest(int num) { data1 = data2 = num; };
	~CTest() {};
	void*       operator new (size_t);
	void        operator delete(void* pTest);
public:

	int         data1;
	int         data2;
};

static MemoryPool Pool(sizeof(CTest));

void CTest::operator delete(void* pTest)
{
	Pool.Free(pTest);
}

void* CTest::operator new(size_t)
{
	return (CTest*)Pool.Alloc();
}

#include <vector>
int main()
{
	std::vector<CTest *> lists;
	for (int i = 0; i < 50; i++)
	{
		CTest* pTest = new CTest(i);
		printf("%d \n", pTest->data2);
		lists.push_back(pTest);
	}
	
	for (auto ptr : lists)
	{
		delete ptr;
	}
	lists.clear();
	
	for (int i = 50; i < 100; i++)
	{
		CTest* pTest = new CTest(i);
		printf("%d \n", pTest->data2);
		lists.push_back(pTest);
	}
	for (auto ptr : lists)
	{
		delete ptr;
	}
	lists.clear();
	
	while (true)
	{
	}
}

效果如图：
在这里插入图片描述

5年1
关注
C++ 内存池
一首小夜曲
05-14 301
关于内存池 在大多分配器中，在标准库中的容器中，一般是用标准库的template <class _Ty, class _Alloc = allocator<_Ty>>；也就是标准库的allocator，使用的是operator new。值得注意的是，此allocator是带有cookie的，内部实际就是一个operator new调用一次malloc。 内存池的设计，一个通...
c++ 内存池的实现
qq_54662616的博客
03-27 1382
平常我们在使用malloc申请内存时，频繁的申请小块内存会造成内存的浪费，所以可以使用内存池来减少内存的浪费。 memory_pool.h #ifndef MEMORY_POOL #define MEMORY_POOL #include <iostream> #define size 20 #define numsize 10 class freenode { public: char data[size]; struct obj { stru
C++ 内存池 -- C++ Memory Pool
热门推荐
10-08 3万+
这是我翻译的文章，来自 Code Project， 原文作者: DanDanger2000. 原文链接: http://www.codeproject.com/cpp/MemoryPool.aspC++ 内存池l  下载示例工程 – 105Kbl  下载源代码 – 17.3Kb目录l 引言l 它怎样工作l 示例l 使用这些代码l 好处l 
内存池化技术详解：提升C++程序性能的关键
最新发布
iShare_Carlos的博客
08-02 2300
在高性能计算中，内存池化可以显著提高内存分配和释放的效率，例如，在科学计算和大数据处理等领域，内存池化技术可以减少内存碎片，提升内存管理的效率，从而加快计算速度。内存池化的应用不仅限于高性能计算和游戏开发，在嵌入式系统中，由于内存资源有限，内存池化可以通过预先分配固定大小的内存块，确保内存使用的高效性和稳定性，在这种环境中，内存池化技术可以显著减少内存碎片，提高系统的稳定性和可靠性。通过使用内存池，可以快速分配和释放内存，提高服务器的处理效率，减少内存管理的开销，从而提升服务器的整体性能。
c++内存分配优先使用内存池，而不是new，delete
mare2012的博客
04-08 179
c++内存分配优先使用内存池，而不是new，delete 容健行@2008-2-1 转载请注明出处 trackback：http://www.devdiv.net/home/space.php?uid=125&amp;do=blog&amp;id=364   认识一下new和delete的开销： new和delete首先会转调用到malloc和free，这个大家应该很熟识了。很多人...
C++内存池
宋文兵的专栏
04-22 1134
原文地址 http://www.cppblog.com/d3d/archive/2008/11/28/68097.aspx SMemoryChunk.h #ifndef __SMEMORYCHUNK_H__#define __SMEMORYCHUNK_H__typedef unsigned char TByte ;struct SMemoryChunk{  TByte *Da
c++内存池
lichao201005的专栏
04-12 1530
此代码可作为商业代码，在使用内存池的场合直接拿来使用，特此记录！ // 分配内存池 嵌入式指针 class allocatorPool { public: //分配 void *allocator(size_t size) { obj *tmplink; if (m_FreePos == nullptr) { //分配内存池 size_t i_realsize = i_sTrunkCount * size; m_FreePos = (obj*)malloc(i_rea
基于C++实现内存池技术 memorypool.zip
06-03
C++是一种广泛使用的编程语言，它是由Bjarne Stroustrup于1979年在新泽西州美利山贝尔实验室开始设计开发的。...因此，无论是初学者还是经验丰富的程序员，都可以通过C++来设计和实现新系统或维护旧系统。3
C++ 实现高性能内存池项目实现
yx5666的博客
10-24 632
本节我们实现了一个用于测试性能比较的模板链表栈，目前的代码如下。在下一节中，我们开始详细实现我们的高性能内存池。{T data;};// T 为存储的对象类型, Alloc 为使用的分配器,// 并默认使用 std::allocator 作为对象的分配器{public:// 使用 typedef 简化类型名// 默认构造}// 默认析构}// 当栈中元素为空时返回 true}// 释放栈中元素的所有内存= 0){curr = tmp;}head_ = 0。
介绍及线程池，C++实现内存池、进程池、线程池
Linux高级开发的博客
05-12 953
内存池 平常我们使用new、malloc在堆区申请一块内存，但由于每次申请的内存大小不一样就会产生很多内存碎片，造成不好管理与浪费的情况。 内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是尽量避免了内存碎片，使得内存分配效率得到提升。 进程池&&线程池 这两个问题有一定的相似度，在面向对象程序编程中，对象的创建与析构都是一个较为...
c/c++内存池
09-26
c/c++内存池 线程安全的c/c++内存池 线程安全的c/c++内存池 线程安全的c/c++内存池 线程安全的c/c++内存池 线程安全的c/c++内存池 线程安全的c/c++内存池 线程安全的c/c++内存池 线程安全的c/c++内存池 线程安全的c/c++内存池 线程安全的c/c++内存池 线程安全的c/c++内存池 线程安全的c/c++内存池 线程安全的c/c++内存池 线程安全的
C++ STL内存池
weixin_30772261的博客
05-08 581
内存池出现原因：内存碎片 　　首先我们需要明确, 内存池的目的到底是什么? 首先你要知道的是, 我们每次使用new T来初始化类型T的时候, 其实发生了两步操作, 一个叫内存分配, 这一步使用的其实不是new而是operator new(也可以认为就是C语言中的malloc), 这一步是直接和操作系统打交道的, 操作系统可能需要经过相对繁琐的过程才能将一块指向空闲内存的指针返回...
c++ 内存池
liuxyen的博客
11-13 629
c++内存池 内存管理是 C++最令人切齿痛恨的问题，也是C++最有争议的问题，C++高手从中获得了更好的性能，更大的自由，C++菜鸟的收获则是一遍一遍的检查代码和对 C++的痛恨，但内存管理在C++中无处不在，内存泄漏几乎在每个C++程序中都会发生，因此要想成为C++高手，内存管理一关是必须要过的，除非放弃 C++，转到Java或者.NET，他们的内存管理基本是自动的，当然你也放弃了自
C++_内存池
Duc_Duke的博客
08-18 294
默认内存管理的不足： malloc/free 和 new/delete 在堆上申请和释放内存都有一定的额外开销。开销来自维护 内存空闲块表。malloc和new 申请堆内存时，首先查找内部维护的内存空闲块表，并且需要根据一定的算法找到合适大小的空闲内存块。如果该空闲内存块过大，还需要切割成已分配的部分和较小的空闲块。然后系统更新内存空闲块表，完成一次内存分配。类似地，在free和delete释放内...
C++实现内存池代码
09-17
下面是一个简单的C代码实现内存池的示例： ```c #include #include typedef struct Node { void* memory; int size; struct Node* next; } Node; typedef struct MemoryPool { int blockSize; Node* head;...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值