allocator类

Cooper_jj123

已于 2022-04-30 15:31:29 修改

阅读量533

点赞数

文章标签：数据结构 c++

于 2022-04-30 15:00:18 首次发布

本文链接：https://blog.csdn.net/qwert55kai/article/details/124511099

版权

最近看动态内存时候准备细细了解一下allocator，记录

基本印象

new有一些灵活性上的局限，其中一方面表现在它将内存分配和对象构造组合在了一起，类似的，delete将对象析构和内存释放组合到了一起。我们分配单个对象时，通常希望将内存分配和对象初始化组合在一起，因为在这种情况下，可以知道对象有什么值
当分配一大块内存时，我们通常计划在这块内存上按需构造对象。在此情况下，我们希望将内存分配和对象构造分离，这意味着我们可以分配大块内存，但只要阵阵需要时才真正执行对象创建操作，同时要付出一定的开销
一般情况下，将内存分配和对象构造组合在一起可能会导致不必要的浪费。标准库allocator 在头文件中，可以做到分配内存和对象构造分离，他分配的内存时原始的、未构造的，
类似vector，allocator是一个模板，为了定义一个allocator对象，我们必须指明这个allocator可以分配的对象类型，当一个allocator对象分配内存时，它会根据给定的对象类型来确定恰当的内存大小和对齐位置：

allocator<string> alloc;      //可以分配string的allocator对象
auto const p = alloc.allocator(n);   //分配n个未初始化的string

这个allocator调用为n个string分配了内存。

allocator<T> a        定义了一个名为a的allocator对象，它可以为类型为T的对象分配内存

a.allocate(n)         分配一段原始的、未构造的内存，保存n个类型为T的对象

a.deallocate(p, n)    释放从T*指针p中地址开始的内存，这块内存保存了n个类型为T的对象；p必须是一个先前由allocate返回的指针，\
					  且n必须是p创建时所要求的大小，在调用deallocate之前，用户必须对每个在这块内存中创建的对象调用destroy

a.construct(p, args)  p必须是一个类型为T*的指针，指向一块原始内存：arg被传递给类型为T的构造函数，用来在p指向的内存中构造一个对象

相比之下，用new分配对象空间的时候，我们知道new会自动调用对象的构造函数，但是有时候我们在为对象开辟空间的时候，其实还没有准备好为对象赋值。

string *p = new string[n]  //开辟空间并构造了n个空字符串对象
for(int i = 0; i < n; ++i)
{
    cin>>p[i]; //为n个字符串对象赋值
}

用new来分配空间，调用构造函数为我们初始化了空字符串，这对我们来说并没有意义，因为我们知道后面通过赋值会覆盖掉原本的初始化值。如果使用allocator

下面是例子：

1.声明allocator类：
allocator<string> a;

2.分配未构造的空间：
string* p = a.allocate(n)  //n个string 类型的原始空间，返回指向空间的指针

3.构造对象：
for(int i=0;i<n;i++)
{    
    string args;
    cin>>args;
    a.construct(p+i,args)  //对每一个对象进行初始化,args是对应的构造函数参数，p必须是对应的allocate分配的指针
}
4.析构对象：
for(int i=0;i<n;i++)
    a.destroy(p+i)
    
5.释放空间：
a.deallocate(p,n)  //p是指针，n是对象个数

可以看到，通过适时的构造对象，我们无需通过赋值操作覆盖原对象的初始值，减少了不必要的操作。

allocator分配未构造的内存

allocator分配的内存是未构造的，我们按需在此内存中构造对象，construct 成员函数接受一个指针和args…个参数，在给定位置构造一个元素，额外参数用来初始化构造的对象，类似 make_shared 的参数，这些额外的参数必须是与构造的对象类型相匹配的合法初始化

auto q = p;                //q指向最后构造的元素之后的位置
alloc.construct(q++);
alloc.construct(q++, 10, 'c');     // *q cccccccccc
alloc.construct(q++, "hi);

这时候

cout << *p << endl;    // 正确  
cout << *q << endl;	   // 错误 q指向的是未构造的内存

当我们用完对象后，必须对每个构造的元素调用destroy来销毁它们，函数destroy接受一个指针，对指向的对象执行析构函数

while(q != p)
	alloc.destroy(--);

一旦元素被销毁后，就可以重新使用这部分内存来保存其他string，也可以将其归还给系统，释放内存通过调用deallocate来完成，

alloc.dealloacte(p, n);

拷贝和填充未初始化内存的算法
标准库还为allocator类定义了两个伴随算法，可以在未初始化内存中创建对象

uninitialized_copy(b, e, b2); 
uninitialized_copy_n(b, n , b2);
uninitialized_fill(b , e, t);
uninitialized_fill_n(b, n, t); 从迭代器b指向的内存地址开始创建n个对象，b必须指向足够大的未构造的原始内存，能够容纳给定数量的对象

一些相关allocate的问题

内存池：内存池的出现是为了管理内存碎片，当我们通过构造函数实例化一个对象，或者使用new创建一个对象的时候，其实是进行了两步操作：
1、首先是使用allocate进行内存分配，这一步是与操作系统相关的，操作系统将一块闲置的内存指针返回给用户，这一步是比较耗时的
2、然后是使用构造函数初始化该内存，由于分配内存比较耗时，那么可以一次性的分配一块很大的内存，然后再需要的时候将其中一部分分给用户，用来管理这一块大内存的数据结构称为内存池
内存的申请流程是由一个一级分配器和一个二级分配器组成的，当要分配的内存大于128k的时候使用一级分配器；当小于等于128k时使用二级分配器。
二级分配器使用自由链表（free-list）技巧，共有16个freelist。各自管理大小分别为8、16、24、32、40、48、56、64、72、80、88、96、104、112、120、128 bytes的小额区块。

所以最终内存池的思路是：
1、使用allocate向内存池请求size大小的内存空间，如果需要请求内存大小>128bytes，直接使用malloc
2、如果需要的内存小于128bytes，allocate根据size找到最合适的自由链表
a、如果链表不为空，返回第一个node，alloacte根据size找到最合适的自由链表
b、如果链表为空，使用blockAlloc请求分配node
x. 如果内存池中有大于一个node的空间, 分配竟可能多的node(但是最多20个), 将一个node返回, 其他的node添加到链表中.
y. 如果内存池只有一个node的空间, 直接返回给用户.
z.如果连一个node都没有，再次向操作系统请求分配内存
①分配成功, 再次进行b过程
②分配失败, 循环各个自由链表, 寻找空间
I. 找到空间, 再次进行过程b
II. 找不到空间, 抛出异常(代码中并未给出, 只是给出了注释)
3、用户调用deallocate释放内存空间, 如果要求释放的内存空间大于128bytes, 直接调用free.
4、否则按照其大小找到合适的自由链表, 并将其插入.

所以有以下特点：
1、刚开始初始化内存池的时候, 其实内存池中并没有内存, 同时所有的自由链表都为空链表.