C++ 对象池 ObjectPool

最新推荐文章于 2025-03-10 20:12:08 发布
最新推荐文章于 2025-03-10 20:12:08 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： C++ 文章标签： c++ 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/XXXTENTAC1ON/article/details/124481574
版权
本文介绍了ObjectPool类的设计与实现，用于管理对象内存，提高效率。通过重载`operator new`和`operator delete`，实现了对象在ObjectPool中的分配与释放。使用单例模式的ObjectPoolBase类提供了获取和归还对象的接口，简化了对象的生命周期管理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

template<class _Ty>
class ObjectPool
{
	enum { nPollSize = 4 };  //最多三个对象
protected:
	struct _Node
	{
		_Node* next;
	};
	_Node* front; //头
	_Node* rear;  //尾
private:
	void ReFillPool() //填充
	{
		size_t total = sizeof(_Node) + sizeof(_Ty);
		for (int i = 0; i < nPoolSize; ++i)
		{
			_Node* s = (_Node*)malloc(total); //_Node 和 对象大小都开辟出来
			new(s + 1) _Ty();                 //在指针后面构造对象
			s->next = nullptr;
			rear->next = s;
			rear = s;
		}

	}
	void InitPool()  //初始化
	{
		if (rear != nullptr) return;
		_Node* head = (_Node*)malloc(sizeof(_Node));
		head->next = nullptr;
		front = rear = head;
	}
public:
	ObjectPool() :front(nullptr), rear(nullptr)
	{
		InitPool();
	}
	~ObjectPool()
	{
		clear();
	}
	_Ty* allocObjMemory() //获得对象池
	{
		if (front == rear) //为空 注入对象
		{
			ReFillPool();
		}
		_Node* s = front->next;  //不为空 取第一个结点
		front->next = s->next;   
		if (s == rear)
		{
			rear = front;
		}
		return (_Ty*)(s + 1); //返回 _Ty 对象 
	}
	void freeObjectMemory(void* pobj)
	{
		_Node* q = (_Node*)((char*)pobj - sizeof(_Node));
		//减去4，回到_Node链表
		q->next = rear->next; //将q 归还给链表 尾插
		rear->next = q;
		rear = q;
	}
};

在构造链表的过程中，尽管链表只有一个next成员，但是由于在链表填充的过程中，多分配了一个对象的空间大小
则该链表结构变成，前面4字节为Node指针，后面的为对象的内存

再看下面的代码

template<class _Ty>
class ObjectPool
{
private:
	enum { nPoolSize = 4 };
protected:
	struct _Node
	{
		_Node* next;
	};
	_Node* front;
	_Node* rear;
	void InitPool()  //初始化
	{
		_Node* s = (_Node*)malloc(sizeof(_Node));
		s->next = nullptr;
		front = rear = s;
		ReFillPool();
	}
	void ReFillPool() //填充
	{
		int total = sizeof(_Node) + sizeof(_Ty);
		for (int i = 0; i < nPoolSize; ++i)
		{
			_Node* s = (_Node*)malloc(total);
			s->next = nullptr;
			rear->next = s;
			rear = s;
		}
	}
	void Clear()
	{
		_Node* p = nullptr;
		while (front->next != nullptr)
		{
			p = front->next;
			front->next = p->next;
			free p;
		}
		free front;
		front = rear = nullptr;
	}
public:
	ObjectPool() :front(nullptr), rear(nullptr)
	{
		InitPool();
	}
	~ObjectPool()
	{
		Clear();
	}
	ObjectPool(const ObjectPool&) = delete;
	ObjectPool& opertaor = (const ObjectPool&) = delete;

	_Ty* allocObjMemory()
	{
		if (front == rear)
		{
			ReFillPool();
		}
		_Node* s = front->next;
		front->next = s->next;
		if (s == rear) rear = front;
		return (_Ty*)((char*)s + sizeof(_Node));
	}
	void freeObjMemory(void* q)
	{
		_Node* p = (_Node*)(char*)q - sizeof(_Node);
		p->next = nullptr;
		rear->next = p;
		rear = p;
	}
};

class Point
{
private:
	float _x;
	float _y;
public:
	Point(float x = 0.0f, float y = 0.0f) :_x(x), _y(y) {}
	Point(const Point&) = default;
	Point& operator = (const Point&) = default;
	~Point() {}
	
public:
	void* operator new(size_t sz) //静态方法 没有this指针
	{
		return malloc(sz);
	}
	//1. 计算大小
	//2. 分配空间
	//3. 返回地址 调用构造函数
	void operator delete(void* p) //size_t sz
	{
		free(p);
	}
	//自动计算指针所指之物的大小，传递给delete
	//系统将new delete默认定义为静态
};
int main()
{
	Point* pa1 = new Point(1, 2);
	delete pa1;
}

系统对象operator new 和 operator delete 的重载进行了作弊行为，系统会将他们自动定义为静态函数，并且会自动计算类型的大小进行传入

  • operator new
  1. 计算大小
  2. 分配空间
  3. 返回地址 调用构造函数
  • delete
  1. 自动计算指针所指之物的大小，传递给delete

根据下面代码，我们在operator new 与 operator delete 调度ObjectPool，但是这样并不属于我们将对象创建好再直接去使用，而是一个一个去构建

template<class _Ty>
class ObjectPool
{
private:
	enum { nPoolSize = 4 };
protected:
	struct _Node
	{
		_Node* next;
	};
	_Node* front;
	_Node* rear;
	void InitPool()  //初始化
	{
		_Node* s = (_Node*)malloc(sizeof(_Node));
		s->next = nullptr;
		front = rear = s;
		ReFillPool();
	}
	void ReFillPool() //填充
	{
		int total = sizeof(_Node) + sizeof(_Ty);
		for (int i = 0; i < nPoolSize; ++i)
		{
			_Node* s = (_Node*)malloc(total);
			s->next = nullptr;
			rear->next = s;
			rear = s;
		}
	}
	void Clear()
	{
		_Node* p = nullptr;
		while (front->next != nullptr)
		{
			p = front->next;
			front->next = p->next;
			free p;
		}
		free front;
		front = rear = nullptr;
	}
public:
	ObjectPool() :front(nullptr), rear(nullptr)
	{
		InitPool();
	}
	~ObjectPool()
	{
		Clear();
	}
	ObjectPool(const ObjectPool&) = delete;
	ObjectPool& opertaor = (const ObjectPool&) = delete;

	_Ty* allocObjMemory()
	{
		if (front == rear)
		{
			ReFillPool();
		}
		_Node* s = front->next;
		front->next = s->next;
		if (s == rear) rear = front;
		return (_Ty*)((char*)s + sizeof(_Node));
	}
	void freeObjMemory(void* q)
	{
		_Node* p = (_Node*)(char*)q - sizeof(_Node);
		p->next = nullptr;
		rear->next = p;
		rear = p;
	}
};

class Point
{
private:
	static ObjectPool<Point> PointPool;
private:
	float _x;
	float _y;
public:
	Point(float x = 0.0f, float y = 0.0f) :_x(x), _y(y) {}
	Point(const Point&) = default;
	Point& operator = (const Point&) = default;
	~Point() {}
	
public:
	void* operator new(size_t sz) //静态方法 没有this指针
	{
		return PointPool.allocObjMemory();
		//函数本身没用this指针，成员属于私有成员，需要指针指向成员
		//PointPool设计为静态对象
	}
	void operator delete(void* p) //size_t sz
	{
		PointPool.freeObjMemory(p);
	}

};
int main()
{
	Point* pa1 = new Point(1, 2);
	Point* pa2 = new Point(3, 4);

	delete pa1;
	delete pa2;
	return 0;
}

template<class _Ty>
class ObjectPool
{
private:
	enum { nPoolSize = 4 };
protected:
	struct _Node
	{
		_Node* next;
	};
	_Node* front;
	_Node* rear;
	void InitPool()  //初始化
	{
		_Node* s = (_Node*)malloc(sizeof(_Node));
		s->next = nullptr;
		new(s + 1) _Ty(); //构建对象
		front = rear = s;
		ReFillPool();
	}
	void ReFillPool() //填充
	{
		int total = sizeof(_Node) + sizeof(_Ty);
		for (int i = 0; i < nPoolSize; ++i)
		{
			_Node* s = (_Node*)malloc(total);
			s->next = nullptr;
			rear->next = s;
			rear = s;
		}
	}
	void Clear()
	{
		_Node* p = nullptr;
		while (front->next != nullptr)
		{
			p = front->next;
			front->next = p->next;
			free(p);
		}
		free(front);
		front = rear = nullptr;
	}
public:
	ObjectPool() :front(nullptr), rear(nullptr)
	{
		InitPool();
	}
	~ObjectPool()
	{
		Clear();
	}
	ObjectPool(const ObjectPool&) = delete;
	ObjectPool& operator=(const ObjectPool&) = delete;

	_Ty* allocObjMemory()
	{
		if (front == rear)
		{
			ReFillPool();
		}
		_Node* s = front->next;
		front->next = s->next;
		if (s == rear) rear = front;
		return (_Ty*)((char*)s + sizeof(_Node));
	}
	void freeObjMemory(void* q)
	{
		_Node* p = (_Node*)(char*)q - sizeof(_Node);
		p->next = nullptr;
		rear->next = p;
		rear = p;
	}
};

template<class _Ty>
class ObjectPoolBase
{
public:
	_Ty* GetObject() //获得对象
	{
		return objpool.allocObjMemory();
	}
	void RetObject(_Ty* p) //归还对象
	{
		objpool.freeObjMemory(p);
	}
	static ObjectPoolBase<_Ty>& instance()
	{
		static ObjectPoolBase<_Ty> objbase;
		return objbase;
	}
private:
	using ClassTypePool = ObjectPool<_Ty>;
	ClassTypePool objpool;
};


class Point
{
private:
	static ObjectPool<Point> PointPool;
private:
	float _x;
	float _y;
public:
	Point(float x = 0.0f, float y = 0.0f) :_x(x), _y(y) {}
	Point(const Point&) = default;
	Point& operator = (const Point&) = default;
	~Point() {}
	
public:
	void* operator new(size_t) = delete;
	void operator delete(void*) = delete;
};

int main()
{
	ObjectPoolBase<Point>& pointpool = ObjectPoolBase<Point>::instance();

	Point* ap = pointpool.GetObject();

	pointpool.RetObject(ap);

	return 0;
}

这里添加ObjectPoolBase类型，使用单例模式来添加一个中间类，提供调用接口

template<class _Ty>
class ObjectPool
{
private:
	enum { nPoolSize = 4 };
protected:
	struct _Node
	{
		_Node* next;
	};
	_Node* front;
	_Node* rear;
	void InitPool()  //初始化
	{
		if (rear != nullptr) return;
		_Node* s = (_Node*)malloc(sizeof(_Node));
		s->next = nullptr;
		front = rear = s;
		ReFillPool();
	}
	void ReFillPool() //填充
	{
		int total = sizeof(_Node) + sizeof(_Ty);
		for (int i = 0; i < nPoolSize; ++i)
		{
			_Node* s = (_Node*)malloc(total);
			new(s + 1) _Ty();//构造对象
			s->next = nullptr;
			rear->next = s;
			rear = s;
		}
	}
	void Clear()
	{
		_Node* p = nullptr;
		while (front->next != nullptr)
		{
			p = front->next;
			front->next = p->next;
			free(p);
		}
		free(front);
		front = rear = nullptr;
	}
public:
	ObjectPool() :front(nullptr), rear(nullptr)
	{
		InitPool();
	}
	~ObjectPool()
	{
		Clear();
	}
	ObjectPool(const ObjectPool&) = delete;
	ObjectPool& operator=(const ObjectPool&) = delete;

	_Ty* allocObjMemory()
	{
		if (front == rear)
		{
			ReFillPool();
		}
		_Node* s = front->next;
		front->next = s->next;
		if (s == rear) rear = front;
		return (_Ty*)((char*)s + sizeof(_Node));
	}
	void freeObjMemory(void* q)
	{
		_Node* p = (_Node*)((char*)q - sizeof(_Node));
		p->next = nullptr;
		rear->next = p;
		rear = p;
	}
};

template<class _Ty>
class ObjectPoolBase
{
public:
	_Ty* GetObject() //获得对象
	{
		return objpool.allocObjMemory();
	}
	void RetObject(_Ty* p) //归还对象
	{
		objpool.freeObjMemory(p);
	}
	static ObjectPoolBase<_Ty>& instance()
	{
		static ObjectPoolBase<_Ty> objbase;
		return objbase;
	}
private:
	using ClassTypePool = ObjectPool<_Ty>;
	ClassTypePool objpool;
};


class Point
{
private:
	static ObjectPool<Point> PointPool;
private:
	float _x;
	float _y;
public:
	Point(float x = 0.0f, float y = 0.0f) :_x(x), _y(y) {}
	Point(const Point&) = default;
	Point& operator = (const Point&) = default;
	~Point() {}
public:
	void operator delete(void*) = delete;

};

int main()
{
	ObjectPoolBase<Point>& pointpool = ObjectPoolBase<Point>::instance();

	Point* ap = pointpool.GetObject();

	pointpool.RetObject(ap);

	return 0;
}
对象池模式 C++实现
u010506128的博客
01-28 1224
  对象池模式（The Object Pool Pattern） 对象池是一种对象复用技术。Mark Grand在《Patterns in Java》描述了对象池的设计模式，它通过管理和复用有限对象来共享某些稀少或必须付出昂贵代价的资源，该模式的UML结构分为3部分。   Reusable：被复用的对象或资源。 Client：复用对象的使用者，1个Client对象可以使用多个复用对象...
C++对象内存池
码事漫谈
12-22 1103
对象内存池是一种有效的资源管理策略，能够显著提高性能，尤其是在高频率使用对象的场景中。通过合理的设计和实现，可以在保证性能的同时，降低内存管理的复杂性。在实际应用中，开发者需要根据具体需求和场景选择合适的对象池实现方式。
C++实现简单的对象池
adr5970的博客
07-04 150
对象池的实现事实上是很easy的 思想也是非常easy的： 用一个队列来存放全部的对象，须要时get一个对象，从队列头取一个对象，当用完后。又一次将该对象投入到队列尾部。 #ifndef OBJ_POOL_H_ #define OBJ_POOL_H_ #include <queue> #include <memory> #include <s...
一个c++对象池的示例
最新发布
weixin_41554427的博客
03-10 981
如果程序需要大量同类型的短期对象，这些对象的构造函数开销很大（例如构造函数要创建很大的、预先指定大小的矢量，来存储数据），分析器确认这些对象的内存分配和释放是一个性能瓶颈，就可以为这些对象创建一个对象池或缓存。每当代码中需要一个对象时，可以从池中请求一个。当使用完对象时，将这个对象返回池中。对象池只创建一次对象，因此对象的构造函数只调用一次，而不是每次需要使用时都调用。因此，对象池适用于构造函数需要为很多对象进行一些设置操作的情况，也适用于通过构造函数之外的方法调用为对象设置一些实例特有的参数。
C++ 实现对象池
codeofcc的博客
01-05 3758
需求无限，但资源有限的情况下，就需要对资源进行专门的管理。不断的申请和释放内存是不合理的，会造成内存的波动，以及内存不受限的增长。比如，实现了一个消息队列，当发消息的速度快于处理消息的速度时，如果不对资源进行控制，就会导致内存不断的增长。除非有专门的内存管理机制，或明确的编译器优化内存复用，否则建立一个资源管理模块是很有必要的。对象池就是一个对限定数量资源复用管理的模块。
C++中的对象池
daojin505的专栏
06-30 138
用C++的对象池技术来减少，不断地分配和释放的所浪费的时间。从而提高效率。   http://lin-style.iteye.com/blog/645364   http://somenlp.info/2010/05/184/
object pool
weixin_30421525的博客
09-19 168
这是一个简单易用的对象池，很多系统对资源的访问快捷性及可预测性有严格要求，列入包括网络连接、对象实例、线程和内存。而且还要求解决方案可扩展，能应付存在大量资源的情形。 object pool针对特定类型的对象循环利用，这些对象要么创建开销巨大，要么可创建的数量有限。而且在pool中的对象需要做到无状态。 如何使用 utility::object_pool_t<in...
C++对象池源码示例
05-28
在提供的文件"ObjectPool"中，很可能包含了一个具体的C++对象池实现，包括了上述四个步骤的代码。这个实现可能包括类定义、对象池的初始化函数、对象的分配和回收方法，以及可能的扩展和收缩池大小的逻辑。通过对...
深度剖析C++对象池自动回收技术实现
01-21
对象池通过对象复用的方式来避免重复创建对象，它会事先创建一定数量的对象放到池中，当用户需要创建对象的时候，直接从对象池中获取即可，用完对象之后再放回到对象池中，以便复用。这种方式避免了重复创建耗时或耗...
使用对象池优化 C++ 程序性能的实用指南
windowshht的博客
08-31 934
对象池是一种缓存机制，用于管理对象的重用。它预先创建一组对象并将其存储在池中，当需要使用对象时，从池中获取一个可用的对象，而不是每次都创建新的对象。当对象不再使用时，它会被返回到池中，而不是被销毁。这样可以显著减少内存分配和释放的频率，从而提高性能。首先，我们定义一个简单的对象类MyObject，它将被对象池管理。public:// 构造函数// 执行某些操作。
对象池（C++）
qq_48757526的博客
06-17 486
对象池
C++实现的对象池，简单好用
08-25
C++实现的对象池，简单好用。就一个h文件，不需要库依赖
C++对象池
田螺姑娘的博客
08-04 1135
在智能指针需要释放的时候调用删除器，将对象重新放入对象池即可。
C++ 对象池
cay22的专栏
07-03 1341
在很多情况下, 你需要new一些对象, 使用很短时间后, 就delete掉. 频繁的new和delete就造成了开销.  所以使用对象池.(这与线程池, 内存池的作用都是一样的). 实现原理: 使用一个列表来保存使用完的对象(而不是delete掉). 如果再次需要使用对象, 就从空闲列表中取出(而不是new出来). 如果空闲列表为空, 这时候才new新的对象.
C++-对象池
qq_43535469的博客
08-09 481
首先我们知道 class Node { public: //struct Obj { Obj* next; }; int a;//4 char b;//1 }; 他的内存大小是8 如果此时添加 struct Obj { Obj* next; };也就是把那个注释取消 会发现还是八个字节 并没有多占用内存 对象池是什么 就是提前分配好例如一千个类对象 然后在需要的时候从这一千个对象中分配对象出去 定义对象池的目的是什么 一个是防止内存碎片化 直接分配一块足够大的内存
c++实现，对象池 object_pool
papaya的博客
11-21 1077
简言 1. boost的对象池object_pool在释放时采用的遍历，有性能问题 2. 也不是什么大问题，优化后可用。但是仅仅为了一个对象池，引入boost，没必要 3. 笔者这里一份简单实现的对象池，windows和linux下通用 4. 代码量很小，仅仅两百行，支持对象池高峰过后，逐步回收 接口介绍 1.// 初始化(初始数量，一次增长的数量， 单次收缩的数量) boo...
C++对象池实现
不会？学啊！
12-10 1246
在实际中，我们会遇到一个类最多只允许若干个对象同时存在的情形。如果这个类的对象会被频繁的创建，使用并销毁，那这时会对系统性能造成影响，而这时可以考虑使用对象池的方法来避免每次使用对象都需要从“构造->使用->销毁”这个流程，对象池中的每个对象都一次构造多次使用，而析构也只会在对象池析构是才会发生。     要实现对象池，那关键问题就在于如果在对象析构时不是真正的析构，而是重新回到对象池中。假如我
C++ ObjectPool_VS2010_非线程安全及线程安全版本
weixin_34392843的博客
05-28 114
// Test.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include &lt;memory&gt; #include &lt;iostream&gt; #include &lt;stack&gt; #include &lt;queue&gt; using namespace std; #pragma once #in...
C++对象池技术：高效对象管理源码解析
C++对象池是一种内存管理策略，它通过复用已经创建的对象来减少频繁的对象创建和销毁带来的性能开销。对象池技术在很多场景中都有应用，比如游戏开发中大量的临时对象创建、网络服务器中的连接对象管理等。使用对象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值