本文主要是介绍C++allocator类，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
new的缺陷
new有一些灵活性上的局限，其中一方面表现在它将内存分配和对象构造组合在了一起。
类似的，delete将对象析构和内存释放组合在了一起。我们分配单个对象时，通常希望将内存分配和对象初始化组合在一起。
因为在这种情况下，我们几乎肯定知道对象应有什么值。
当分配一大块内存时，我们通常计划在这块内存上按需构造对象。
在此情况下，我们希望将内存分配和对象构造分离。这意味着我们可以分配大块内存，但只在真正需要时才真正执行对象创建操作(同时付出一定开销)。
一般情况下，将内存分配和对象构造组合在一起可能会导致不必要的浪费。
例如：
string*const new string[n]; //构造n个空string
string s;
string*q = p;// q指向第一个string
while (cin >> s && q !=p + n)
*g++ = s; //赋予*q一个新值
const size_t size=q-p; //记住我们读取了多少个string
//使用数组
delete[] p; // p指向一个数组；记得用delete[]来释放new表达式分配并初始化了n个string。
但是，我们可能不需要n个string，少量string可能就足够了。这样，我们就可能创建了一些永远也用不到的对象。
而且，对于那些确实要使用的对象，我们也在初始化之后立即赋予了它们新值。每个使用到的元素都被赋值了两次：第一次是在默认初始化时，随后是在赋值时。
更重要的是，那些没有默认构造函数的类就不能动态分配数组了。
allocator类
标准库allocator类定义在头文件memory中，它帮助我们将内存分配和对象构造分离开来。
它提供一种类型感知的内存分配方法，它分配的内存是原始的、未构造的。
类似 vector, allocator 是一个模板。
为了定义一个allocator对象，我们必须指明这个allocator 可以分配的对象类型。
当一个allocator对象分配内存时，它会根据给定的对象类型来确定恰当的内存大小和对齐位置：
allocator<string> alloc; //可以分配string的allocator对象
auto const p = alloc.allocate (n); // 分配n个未初始化的string这个allocate调用为n个string分配了内存。
标准库allocator类及其算法
| 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指向的内存中构造个对象 |
| a.destroy(p) | p为T*类型的指针，此算法对p指向的对象执行析构函数 |
allocator分配未构造的内存
allocator分配的内存是未构造的。我们按需要在此内存中构造对象。
在新标准库中，construct成员函数接受一个指针和零个或多个额外参数，在给定位置构造一个元素。额外参数用来初始化构造的对象。
类似make_shared的参数，这些额外参数必须是与构造的对象的类型相匹配的合法的初始化器：
auto q=p;// q指向最后构造的元素之后的位置
alloc.constuct(g++);// *q为空字符串
alloc.construct(g++, 10,'c'); // *g为cccccccccc
alloc.construct (q++, "hi"); // *q为hi!在早期版本的标准库中，construct只接受两个参数：指向创建对象位置的指针和一个元素类型的值。因此，我们只能将一个元素拷贝到未构造空间中，而不能用元素类型的任何其他构造函数来构造一一个元素。
还未构造对象的情况下就使用原始内存是错误的：
cout << *p << endl;// 正确：使用 string的输出运算符
cout << *g << endl;// 灾难：q指向未构造的内存!为了使用allocate返回的内存，我们必须用 construct构造对象。使用未构造的内存，其行为是未定义的。
当我们用完对象后，必须对每个构造的元素调用destroy来销毁它们。函数destroy接受一个指针，对指向的对象执行析构函数；
while (q != p)
alloc.destroy(--q)；//释放我们真正构造的string在循环开始处，q指向最后构造的元素之后的位置。我们在调用destroy之前对q进行了递减操作。因此，第一次调用destroy时，q指向最后一个构造的元素。最后一步循环中我们destroy了第一个构造的元素，随后q将与p相等，循环结束。
我们只能对真正构造了的元素进行destroy操作。
一旦元素被销毁后，就可以重新使用这部分内存来保存其他string，也可以将其归还给系统。释放内存通过调用deallocate来完成：
alloc.deallocate (p, n)；我们传递给deallocate的指针不能为空，它必须指向由allocate分配的内存。
而且，传递给deallocate的大小参数必须与调用allocated 分配内存时提供的大小参数具有一样的值。
拷贝和填充未初始化内存的算法
标准库还为allocator类定义了两个伴随算法，可以在未初始化内存中创建对象。表12.8描述了这些函数，
它们都定义在头文件memory中。
| uninitialized_copy (b, e, b2) | 从迭代器b和e指出的输入范围中拷贝元素到迭代器b2 指定的未构造的原始内存中。b2指向的内存必须足够大，能容纳输入序列中元素的拷贝 |
| uninitialized_copy_n(b, n, b2) | 从迭代器b指向的元素开始，拷贝n个元素到b2开始的内存中 |
| uninitialized fill(b, e, t) | 在迭代器b和e指定的原始内存范围中创建对象，对象的值均为t的拷贝 |
| uninitialized fill n(b,n,t) | 从迭代器b指向的内存地址开始创建n个对象。b必须指向足够大的未构造的原始内存，能够容纳给定数量的对象 |
这些函数在给定目的位置创建元素，而不是由系统分配内存给它们。
作为一个例子，假定有一个int的vector，希望将其内容拷贝到动态内存中。我们将分配一块比vector中元素所占用空间大一倍的动态内存，然后将原vector中的元素拷贝到前一半空间，对后一半空间用一个给定值进行填充：
// 分配比 vi 中元素所占用空间大一倍的动态内存 484
auto p=alloc.allocate (vi,size()*2)；
// 通过拷贝vi中的元素来构造从p开始的元素
auto g - uninitialized_copy (vi.begin(), vi.end(), p);
// 将剩余元素初始化为 42
uninitialized fill n(q, vi.size(), 42)；类似拷贝算法，uninitialized_copy接受三个迭代器参数。前两个表示输入序列，第三个表示这些元素将要拷贝到的目的空间。
传递给uninitialized_copy的目的位置迭代器必须指向未构造的内存。与copy不同uninitialized_copy在给定目的位置构造元素。
类似 copy,uninitialized copy返回(递增后的)目的位置迭代器。
因此，一次uninitialized_copy调用会返回一个指针，指向最后一个构造的元素之后的位置。在本例中，我们将此指针保存在q中，然后将q传递给uninitialized fill n。此函数类似 fill_n，接受一个指向目的位置的指针、一个计数和一个值。
它会在目的位置指针指向的内存中创建给定数目个对象，用给定值对它们进行初始化。
这篇关于C++allocator类的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
