Boost库基础-pool库

迷南。 2023-07-18 06:21 18阅读 0赞

> pool库

内存池预先分配了一块大的内存空间，然后就可以在其中使用某种算法实现高效快速的自定制内存分配。

boost.pool库基于简单分隔存储思想实现了一个快速、紧凑的内存池库，不仅能够管理大量的对象，还可以被使用做STL的内存分配器。某种程度上讲，它近似于一个小型的垃圾回收机制，在需要大量地分配/释放小对象时很有效率，而且完全不需要考虑delete。

pool库包含4个组成部分：

1.最简单的pool

2.分配类实例的object\_pool

3.单件内存池singleton\_pool

4.可用于标准库的pool\_alloc

> pool类

pool是最简单容易使用的内存池类，可以返回一个简单数据类型的内存指针。需要包含以下文件

#include <boost/pool/pool.hpp>
    using namespace boost;

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6ejk1MzIwMDQ2Mw_size_16_color_FFFFFF_t_70][]

①模板类型参数UserAllocator是一个用户定义的内存分配器，它实现了特定的内存分配算法，通常可以直接用默认的default\_user\_allocator\_new\_delete，它内部使用new\[ \] 和delete\[ \]分配内存。

②构造函数接受一个siez\_type类型的整数，指示每次pool分配内存块的大小(而不是pool内存池的大小)，这个值可以用get\_requested\_size()获得。pool会根据需要自动地向系统申请或归还使用的内存，在析构时，pool将自动释放它所持有的所有内存块。

③成员函数malloc()和ordered\_malloc()的行为很类似C中的全局函数malloc()，返回从内存池中分配的内存块，大小为构造函数中指定的requested\_size。malloc()从内存池中任意分配一个内存块，而ordered\_malloc()则在分配的同时合并空闲块链表。ordered\_malloc()带参数的行为还可以连续分配n块的内存。分配后的内存块可以用is\_from()函数测试是否从这个内存池分配出去的。

④release\_memory()释放所有未被分配的内存，但已分配的内存块不受影响；purge\_memory()则强制释放pool持有的所有内存，不管内存块是否被使用。pool的析构函数就是调用purge\_memory()。

**使用：**

#include <iostream>
    #include <boost/pool/pool.hpp>
    #define BOOST_SYSTEM_NO_DEPRECATED		//避免链接boost.system库
    using namespace boost;
    
    int main()
    {
    	//一个可分配int的内存池
    	pool<> p1(sizeof(int));
    
    	//转换成需要的类型
    	int *p = static_cast<int *>(p1.malloc());
    
    	//释放内存池分配的内存块
    	p1.free(p);
    
    	//连续分配大量的内存
    	for (int i = 0; i < 100; i++)
    	{
    		p1.ordered_malloc(10);
    	}
    
    	getchar();
    	return 0;
    }//内存池对象析构，所有分配的内存都被释放

**注意：只能作为普通数据类型如int、double等的内存池。**

> object\_pool

是用于类实例（对象）的内存池，功能与pool类似，析构时对所有已经分配的内存块调用析构函数。

#include <boost/pool/object_pool.hpp>
    using namespace boost;

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6ejk1MzIwMDQ2Mw_size_16_color_FFFFFF_t_70 1][]

①construct()实际上是一组函数，有多个参数的重载形式（目前最多支持3个参数），它先调用malloc()分配内存，然后再内存块上使用传入的参数调用类的构造函数，返回一个已经初始化的对象指针。

②destory()则先调用对象的析构函数，然后再用free()释放内存块。

**用法：**

#include <iostream>
    #include <string>
    #include <boost/pool/object_pool.hpp>
    using namespace boost;
    
    //示例类
    struct demo_class
    {
    public:
    	int a, b, c;
    	demo_class(int x= 1,int y =2 ,int z = 3):a(x),b(y),c(z){}
    };
    
    int main()
    {
    	//对象内存池
    	object_pool<demo_class> p1;
    
    	//分配一个原始内存块
    	auto p = p1.malloc();
    
    	//构造一个对象，可以传递参数
    	p = p1.construct(7, 8, 9);
    
    	//定义一个分配string对象的内存池
    	object_pool<std::string> pls;
    
    	//连续分配大量string对象
    	for (int i = 0; i < 10; ++i)
    	{
    		std::string *ps = pls.construct("hello");
    		std::cout << *ps << std::endl;
    	}
    
    	getchar();
    	return 0;
    }//内存池对象析构，所有分配的内存都被释放

> singleton\_pool

它与pool的接口完全一致，可以分配简单数据类型的内存指针，但它是一个单件。

#include <boost/pool/singleton_pool.hpp>
    using namespace boost;

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6ejk1MzIwMDQ2Mw_size_16_color_FFFFFF_t_70 2][]

①它有两个模板类型参数，第一个Tag仅仅是用于标记不同的单件，可以是空类，甚至是声明；第二个参数RequestedSize等同于pool构造函数中的整数requested\_size，指示分配内存块的大小。

②它与pool接口完全一致，但成员函数均是静态的。

**用法：**

#include <iostream>
    #include <string>
    #include <boost/pool/singleton_pool.hpp>
    #define BOOST_POOL_NO_MT	//不适用多线程
    using namespace boost;
    
    //仅仅用于标记的空类
    struct pool_tag{};
    
    //内存池定义
    typedef singleton_pool<pool_tag, sizeof(int)> sp1;
    
    int main()
    {
    	//分配一个整数内存块
    	int *p = (int *)sp1::malloc();
    
    	//释放所有未分配的内存
    	sp1::release_memory();
    
    	getchar();
    	return 0;
    }//内存池对象析构，所有分配的内存都被释放

> pool\_alloc

pool\_alloc提供了两个可以用于标准容器模板参数的内存分配器，分别是pool\_alloc和fast\_pool\_allocator，它们的行为与之前的内存池类有一点不同——内存分配失败会抛出异常std::bad\_alloc。

**用法：**

#include <iostream>
    #include <vector>
    #include <boost/pool/pool_alloc.hpp>
    
    using namespace boost;
    
    int main()
    {
    	std::vector<int, pool_allocator<int>> v;
    
    	v.push_back(10);
    
    	getchar();
    	return 0;
    }//内存池对象析构，所有分配的内存都被释放

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6ejk1MzIwMDQ2Mw_size_16_color_FFFFFF_t_70]: /images/20230528/0b26479865d2444d9dad89539eb3f541.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6ejk1MzIwMDQ2Mw_size_16_color_FFFFFF_t_70 1]: /images/20230528/0c05697167b646c9bc7ed8d73ab8d6e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6ejk1MzIwMDQ2Mw_size_16_color_FFFFFF_t_70 2]: /images/20230528/4c031d1ecc3e4889ae3f276d5244bd00.png