使用C++11实现对象池

最新推荐文章于 2024-06-09 10:01:06 发布
最新推荐文章于 2024-06-09 10:01:06 发布
阅读量692 收藏 3
点赞数
分类专栏： C++或Windows 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/handsomeasme/article/details/126540480
版权

这里写自定义目录标题

使用C++11实现对象池

基本功能介绍

本文使用现代C++语法实现了一个简单的对象池，主要提供了以下功能：

  • 支持创建指定大小的对象池
  • 支持对象池中的对象通过可变参数的方式进行创建，提高了对象池的通用性
  • 使用模板，可以创建不同类型的对象池对象
  • 支持对对象池中的对象进行使用率统计
  • 支持获取对象池中不在使用的对象
  • 支持对象池的扩容，暂时只提供外界调用者进行扩容的行为，不主动扩容

相关代码基本介绍

ObjectPool

对象池对象。

ObjWrapper

对对象池中的对象进行包装，提供m_bUsing属性来判断当前池中的对象是处于在使用状态还是不在使用状态。

模板参数T

对象池可以创建的对象的类型。

template<typename… Args>

对象池中对象的构造过程通过外界传入的参数来动态选择相应构造函数对池中对象进行构造。

代码

其中具体的解释我都以注释的方式在代码中进行了说明。

ObjectPool.h

#pragma once

#include<vector>
#include<memory>

/*
* 暂时使用vector作为对象池对象的存储容器
*/
template<typename T>
class ObjectPool
{
public:
	/*
	* 提供无参构造，可以在不传递任何参数时创建对象池对象
	*/
	ObjectPool() {}

	/*
	* 提供带参数的构造，并指定创建对象池时所创建对象的构造函数的参数列表
	*/
	template<typename... Args>
	ObjectPool(int num, Args... args)
	{
		CreatePoolObjs(num, std::forward<Args>(args)...);
	}

	/*
	* 析构函数中将对象池的对象进行清除
	* 这样外面代码就不需要显式调用ClearObjs来清除，减少出错机会
	* 
	* 随便举一个出错机会
	* 如果外面代码是通过RAII的方式来管理对象池对象，外面代码必须主动调用ClearObjs来清除
	* 见main.cpp tt4()函数
	* auto pool = std::make_shared<ObjectPool<Teacher>>(10, "张三", 20);
	* auto pool = std::shared_ptr<ObjectPool<Teacher>>(new ObjectPool<Teacher>(10, "张三", 20));
	*/
	~ObjectPool() { ClearObjs(); }

	class ObjWrapper
	{
	public:
		/*
		* 对原始的T对象进行包装，提供一些额外的公用属性，比如对象是否在被使用(m_bUsed)
		* 
		* 使用外界传进来参数列表来动态创建T对象
		* 要求T类型有该参数列表的构造函数
		*/
		template<typename... Args>
		ObjWrapper(Args... args)
		{
			printf("create obj: %p\n", this);
			//obj = new T(std::forward<Args>(args)...);
			m_obj = std::make_shared<T>(std::forward<Args>(args)...);
			m_bUsing = false; // 创建时状态为当前不在使用
		}

		~ObjWrapper()
		{
			printf("destroy obj: %p\n", this);
			//delete obj; //如果成员变量是T* obj;类型，且构造函数有new的行为，需要在析构函数中手动回收空间	
		}

		void SetUsing(bool bUsed)
		{
			m_bUsing = bUsed;
		}

		bool IsUsing()
		{
			return m_bUsing;
		}

		/*
		* 返回被包装的原始对象
		*/
		/*T* GetRawObj()
		{
			return obj;
		}*/

		std::shared_ptr<T> GetObj()
		{
			return m_obj;
		}
	private:
		//T* obj;					// 直接是原始对象，需要ObjWrapper中实现对原始对象的内存释放
		std::shared_ptr<T> m_obj;	// 原始对象的RAII，自动内存管理，不需要自己管理原始对象的内存释放
		bool m_bUsing;
	};

	/*
	* 为对象池一次性创建num个内存对象
	* 支持可变参数的构造
	*/
	template<typename... Args>
	void CreatePoolObjs(int num, Args... args)
	{
		for (int i=0;i<num;i++)
		{
			auto obj = std::make_shared<ObjWrapper>(std::forward<Args>(args)...);//std::move(args)...
			m_objs.push_back(std::move(obj));// 使用移动语义，代替m_objs.push_back(obj);
		}		
	}

	/*
	* 往对象池中增加一个对象，此行为会改变对象池的大小
	* 支持可变参数的构造
	* 当对象池中对象都处于被使用的状态时可以用此函数对对象池进行相应扩容
	*/
	template<typename... Args>
	void PushObj(Args... args)
	{
		auto obj = std::make_shared<ObjWrapper>(std::forward<Args>(args)...);
		m_objs.push_back(std::move(obj));
	}

	/*
	* 获取对象池中的一个未使用的对象
	* 这里暂时使用简单的O(N)行为来获取一个当前未使用的对象，暂时没做扩容处理(TODO:使用者可以根据自己需要进行相应扩容处理)
	*/
	std::shared_ptr<ObjWrapper> GetUnUsingOne()
	{
		for (auto obj : m_objs)
		{
			if (!obj->IsUsing())
			{
				return obj;
			}
		}
		return nullptr;
	}

	/*
	* 统计对象池的使用率
	*/
	double GetUsingRatio()
	{
		auto total = GetSize();
		if (total == 0)
		{
			return 0.0;
		}

		int useCount = 0;
		for (size_t i = 0; i < total; i++)
		{
			if (m_objs[i] && m_objs[i]->IsUsing())
			{
				useCount++;
			}
		}
		return (double)useCount / (double)total;
	}

	/*
	* 复用对象池中的数据
	* 只设置use标识，不更改数据，后续可根据实际业务来更改数据内容
	*/
	void ReUsePool()
	{
		for (size_t i = 0; i < GetSize(); i++)
		{
			if (m_objs[i] != nullptr)
			{
				m_objs[i]->SetUsing(false);
			}		
		}
	}

	/*
	* 返回对象池中对象个数
	*/
	size_t GetSize()
	{
		return m_objs.size();
	}

private:
	/*
	* 清空对象池中的对象
	* 设为私有，不允许外部显式调用来清空对象池中的对象
	*/
	void ClearObjs()
	{
		m_objs.clear();
	}
private:
	std::vector<std::shared_ptr<ObjWrapper>> m_objs;
};

测试代码

#include <iostream>
#include <string>
#include <memory>
#include"ObjectPool.h"

using namespace std;

class Teacher {
public:
	/*
	* 提供无参构造函数
	*/
	Teacher() :m_name(__func__), m_age(0) {}
	/*
	* 提供只设置年龄的构造函数
	*/
	Teacher(int age) : m_name(__func__), m_age(age)
	{
	}
	/*
	* 提供初始化姓名和年龄的构造函数
	*/
	Teacher(const string& name, int age) : m_name(name), m_age(age)
	{
	}
	/*
	* 析构函数
	*/
	~Teacher() {
	}

	/*
	* 拷贝构造函数
	*/
	Teacher(const Teacher& a){
		m_name = a.m_name;
		m_age = a.m_age;
	}

	/*
	* 等号运算符的重载
	*/
	Teacher& operator=(const Teacher& a) {
		m_name = a.m_name;
		m_age = a.m_age;
	}

	/*
	* 获取名字
	*/
	string get_name() {
		return m_name;
	}

	/*
	* 获取年龄
	*/
	int get_age()
	{
		return m_age;
	}
private:
	std::string m_name;
	int m_age;
};

void tt3()
{
	ObjectPool<Teacher> pool;

	pool.CreatePoolObjs(10,24);		// 创建一个初始大小为10的对象池
	pool.PushObj(60);					// 往对象池里面新增一个对象，支持可变参数
	pool.PushObj("zhangsan",30);	// 往对象池里面新增一个对象，支持可变参数

	for (size_t i = 0; i < pool.GetSize(); i++)
	{
		auto obj = pool.GetUnUsingOne();
		if (obj != nullptr && obj->GetObj()!=nullptr)
		{
			//printf("%p's name=%s, age = % d\n", obj.get(), obj->GetRawObj()->get_name().c_str(), obj->GetRawObj()->get_age());
			printf("%p's name=%s, age = % d\n", obj.get(), obj->GetObj()->get_name().c_str(), obj->GetObj()->get_age());
			obj->SetUsing(true);
		}	
	}

	// 打印查看对象池的使用率
	printf("object pool use ratio: %.2lf%%\n", pool.GetUsingRatio()*100);
	// 重用对象池对象，设置池中所有对象使用状态为未使用
	pool.ReUsePool(); 

	// 重用对象池对象后打印查看对象池的使用率
	printf("\n\nAfter ReUsePool, object pool use ratio: %.2lf%%\n\n", pool.GetUsingRatio()*100);

	// 检查是否真的可以重用了，打印可重用对象的信息
	for (size_t i = 0; i < pool.GetSize(); i++)
	{
		auto obj = pool.GetUnUsingOne();
		if (obj != nullptr && obj->GetObj() != nullptr)
		{
			printf("%p's name=%s, age = % d\n", obj.get(), obj->GetObj()->get_name().c_str(), obj->GetObj()->get_age());
			obj->SetUsing(true);
		}
	}
}

void tt4()
{
	// 创建对象个数为10的对象池，并对每个对象初始化为["张三",20],这里调用了Teacher带两个参数的构造函数对
	// 对象池中的对象进行初始化
	// ObjectPool<Teacher> pool(10,"张三",20); 普通栈变量

	// 以下两种方式都可创建对象池对象的RAII对象
	auto pool = std::make_shared<ObjectPool<Teacher>>(10, "张三", 20);//RAII栈变量(管理堆区内存)
	//auto pool = std::shared_ptr<ObjectPool<Teacher>>(new ObjectPool<Teacher>(10, "张三", 20)); 

	// 对每一个不在使用的对象进行操作，用完后设置状态为正在使用中
	// 以打印这个行为来模拟使用对象池中的对象这个行为
	for (size_t i = 0; i < pool->GetSize() ; i++)
	{
		auto obj = pool->GetUnUsingOne();
		if (obj != nullptr)
		{
			//printf("%p's name=%s, age = % d\n", obj.get(), obj->GetRawObj()->get_name().c_str(), obj->GetRawObj()->get_age());
			printf("%p's name=%s, age = % d\n", obj.get(), obj->GetObj()->get_name().c_str(), obj->GetObj()->get_age());
			obj->SetUsing(true);
		}
	}
}


int main()
{
	tt3();
	//tt4();
	return 0;
}

测试结果

以下展示其中一种测试结果，因为每次执行分配的内存单元是不一样的。

create obj: 0098C6E4
create obj: 0098C84C
create obj: 0098C414
create obj: 0098C534
create obj: 0098CA8C
create obj: 0098C45C
create obj: 0098C8DC
create obj: 0098C774
create obj: 0098C57C
create obj: 0098C924
create obj: 0098CAD4
create obj: 0098C4EC
0098C6E4's name=Teacher, age =  24
0098C84C's name=Teacher, age =  24
0098C414's name=Teacher, age =  24
0098C534's name=Teacher, age =  24
0098CA8C's name=Teacher, age =  24
0098C45C's name=Teacher, age =  24
0098C8DC's name=Teacher, age =  24
0098C774's name=Teacher, age =  24
0098C57C's name=Teacher, age =  24
0098C924's name=Teacher, age =  24
0098CAD4's name=Teacher, age =  60
0098C4EC's name=zhangsan, age =  30
object pool use ratio: 100.00%


After ReUsePool, object pool use ratio: 0.00%

0098C6E4's name=Teacher, age =  24
0098C84C's name=Teacher, age =  24
0098C414's name=Teacher, age =  24
0098C534's name=Teacher, age =  24
0098CA8C's name=Teacher, age =  24
0098C45C's name=Teacher, age =  24
0098C8DC's name=Teacher, age =  24
0098C774's name=Teacher, age =  24
0098C57C's name=Teacher, age =  24
0098C924's name=Teacher, age =  24
0098CAD4's name=Teacher, age =  60
0098C4EC's name=zhangsan, age =  30
destroy obj: 0098C6E4
destroy obj: 0098C84C
destroy obj: 0098C414
destroy obj: 0098C534
destroy obj: 0098CA8C
destroy obj: 0098C45C
destroy obj: 0098C8DC
destroy obj: 0098C774
destroy obj: 0098C57C
destroy obj: 0098C924
destroy obj: 0098CAD4
destroy obj: 0098C4EC

F:\HappyCoding\obj_pool\Debug\obj_pool.exe (process 23724) exited with code 0.
Press any key to close this window . . .

最后说明

欢迎大佬进行指导。

小沙弥爱吃肉
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
对象池（C++）
qq_48757526的博客
06-17 405
对象池
284-C++对象池
weixin_45964837的博客
03-30 1017
1.对象池是通过模板来实现的 2.对象池是一个链表 template<class _Ty> class ObjectPool { enum {nPoolSize = 4}; protected: struct _Node { _Node* next; }; _Node* front; _Node* rear; private: void ReFillPool() { size_t total = sizeof(_Node) + sizeof(_Ty);//_Node节点的
Object Pool 对象池的C++11使用（转）
weixin_38169798的博客
07-28 259
很多系统对资源的访问快捷性及可预测性有严格要求，列入包括网络连接、对象实例、线程和内存。而且还要求解决方案可扩展，能应付存在大量资源的情形。 object pool针对特定类型的对象循环利用，这些对象要么创建开销巨大，要么可创建的数量有限。而且在pool中的对象需要做到无状态。 然后转了这位博主的代码，还在研究中 const int MaxObjectNum = 10; ...
C++对象池
田螺姑娘的博客
08-04 1035
在智能指针需要释放的时候调用删除器，将对象重新放入对象池即可。
C++对象池设计与实现
最新发布
HuanBianCheng27的博客
06-09 1004
线程池、连接池、内存池池化技术共同点提前创建资源，以备不时之需时重复利用，极致的提升性能。由于在实际应用里分配内存、创建进程、线程，都会涉及到一些系统调用，系统调用需要导致程序从用户态切换到内核态，是非常耗时的操作。因此，当程序中需要频繁的进行内存申请释放，进程、线程创建销毁等操作时，通常会使用内存池、进程池、线程池等技术来提升程序的性能。对象池简介。
C++11对象池
chuixianghai2403的博客
11-27 317
构想： 基于C++11封装一个简易的对象池，输出使用 std::vector 存储对象成员，对外提供 std::uniqued_ptr 避免忘记销毁，std::uniqued_ptr释放是自动放回std::vector的尾部。提供最少的接口：add，用于添加一个成员；get，用于获取一个成员；...
C++利用智能指针shared_ptr实现对象池
逐梦科学
01-28 1545
C++中用new来分配对象，还要显式的调用delete来析构对象，很容易造成内存泄露。所以在研究我们游戏服务器的代码的时候发现，我们将new函数封装，在对象池上，利用shared_ptr的特性来自动释放对象，同时实现了一种简单的GC回收对象的机制。看完之后，觉得搞的不错，这样很容易管理项目中new。所以把相关代码分享一下。 首先说下基本思路，对象池，其实就是个vector，里面放的是pair,b
c++实现对象池测试.rar
11-21
由于boost的object_pool实现的效率有点低，所以笔者自己写了一个简单的对象池实现，windows和linuxs下通用，具体博客见 https://blog.csdn.net/yzf279533105/article/details/103177192
C++实现的对象池，简单好用
08-25
C++实现的对象池，简单好用。就一个h文件，不需要库依赖
深度剖析C++对象池自动回收技术实现
01-21
本文将探讨对象池的技术特性以及源码实现。 对象池类图 ObjectPool：管理对象实例的pool。 Client：使用者。 适用性： 类的实例可重用。 类的实例化过程开销较大。 类的实例化的频率较高。 效果： 节省了创建类实例...
MemoryPool:使用 C++11 的简单内存池实现
06-13
在C++11中，我们可以利用其新引入的特性来实现一个简单的内存池。本项目就是针对这一主题的一个实践，适用于Visual Studio 2015、g++4.8和clang++3.4等编译器。 内存池的基本思想是避免频繁的系统调用，因为传统的...
对象池模板
10-27
使用对象池，减少new和delete的次数，提供运行效率，减少内存碎片，统一管理内存，防止new和delete用得不当导致内存泄露，对应的博客链接：http://blog.csdn.net/d704791892/article/details/40486261
c++11 对象池的实现
weixin_30879833的博客
03-12 113
const int MaxObjectNum = 10; template <typename T> class ObjectPool { template <typename... Args> using Constructor = std::function<std::shared_...
C++11 使用可变参数模板类实现对象池
qq_28107929的博客
04-30 380
对象池模板类： #pragma once #include "CObjInstance.h" #include <mutex> #include <vector> #include <map> /// <summary> /// 实现模板类型对象池，使其可以适配任何类类型且是线程安全的！！！ /// </summary> templat...
C++的对象池实践
sinat_31608641的博客
02-17 829
对象池
template＜typename ... Args＞：可变参数模板的解释和使用
Major_S的博客
09-27 3777
【代码】template：可变参数模板的解释和使用。
C++：对象池的实现
Rain的博客
03-13 1514
对象池的实现 对象池：在一部分内存空间（池子）中事先实例化好固定数量的对象，当需要使用池中的对象时，首先判断该池中是否有闲置（暂未使用）的对象，如果有，则取出使用，如果没有，则在池中创建该对象。当一个对象不再被使用时，其应该将其放回对象池，以便后来的程序使用。 我们来看实例了解一下为什么需要对象池呢？ 我们先来看一下这样一个例子： //Author:Mr.Rain #include <ios...
C++高级编程----对象池实例
qq_37172182的博客
12-11 872
背景：当尝试使用C++进行代码优化时，可以考虑从语言层次和设计层次进行性能优化。 1）语言层次：语言层次可以考虑从形参传递方式和返回值类型以及异常类型进行控制。 按引用传递：由于C++按值传递会有一定的复制开销，而按引用可以避免复制开销，如果不希望改变引用值，建议进行const修饰；对于复杂对象的创建（销毁），按值引用可能带来不必要地调用其他成员变量的构造函数（析构函数） 按引用返回：同样从函数的返回的角度考虑，按引用传递能避免不必要的复制开销；自C++11之后支持移动语义，允许高效地使用按值返回对象；
使用C++11封装一个对象内存池类
06-10
好的，我可以为您提供一个简单的实现，具体如下： ```c++ #include <iostream> #include <vector> #include <mutex> template <typename T> class ObjectPool { public: ObjectPool(size_t initSize = 10) : initSize_(initSize) { // 初始化对象池 for (size_t i = 0; i < initSize_; ++i) { pool_.push_back(new T()); } } ~ObjectPool() { // 释放对象池 for (auto obj : pool_) { delete obj; } } T* acquire() { std::unique_lock<std::mutex> lock(mutex_); if (!pool_.empty()) { // 从对象池中获取一个对象 T* obj = pool_.back(); pool_.pop_back(); return obj; } else { // 对象池已经空了，需要新建一个对象 return new T(); } } void release(T* obj) { std::unique_lock<std::mutex> lock(mutex_); // 将对象归还到对象池中 pool_.push_back(obj); } private: size_t initSize_; // 初始对象池大小 std::vector<T*> pool_; // 对象池 std::mutex mutex_; // 互斥锁 }; ``` 使用方法如下： ```c++ class MyClass { public: MyClass(int a, int b) : a_(a), b_(b) {} void print() { std::cout << "a = " << a_ << ", b = " << b_ << std::endl; } private: int a_, b_; }; int main() { ObjectPool<MyClass> pool(5); MyClass* obj1 = pool.acquire(); obj1->print(); MyClass* obj2 = pool.acquire(); obj2->print(); pool.release(obj1); MyClass* obj3 = pool.acquire(); obj3->print(); pool.release(obj2); pool.release(obj3); return 0; } ``` 输出结果如下： ``` a = 0, b = 0 a = 0, b = 0 a = 0, b = 0 ``` 您可以根据自己的需求进行修改和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值