allocator类

一、动态数组

【new的局限性】

　　new将内存分配和对象构造组合在一起，同样delete将对象析构和内存释放组合在一起

　　我们分配单个对象时，通常希望将内存分配和对象初始化组合在一起（我们知道对象应有什么值），但分配一大块内存时，我们往往计划在这块内存上按需构造对象→将内存分配和对象构造分离，即我们可以分配大块内存，但只在需要时才真正执行对象创建操作

示例：

string *const p = new string[n];	//new表达式分配并初始化了n个string
string s;
string *q = p;
while (cin >> s && q != p + n) {	//可能不需要n个string
	*q++ = s;						//赋予string新值（创建时已经初始化一次）
}
delete []p;

注：每个使用到的元素都被赋值了两次（第一次是默认初始化，第二次是在赋值时）

二、allocator类

1. 特点

• 是一个模板类型，定义其对象时必须指明它可以分配的对象类型
• 将内存分配和对象构造分离开来
• 它分配的内存是原始的、未构造的（我们需要在此内存中构造对象）

2. 操作

操作	说明
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指向的内存中构造一个对象，p必须是一个类型为T*的指针，指向一块原始内存 args可以是零个或多个参数，用来初始化构造的对象
a.destroy(p)	对p指向的对象执行析构函数，p为T*类型的指针

3. 备注

• 禁止使用未构造对象的原始内存
• 禁止对未构造对象的原始内存进行destroy操作
• 元素被销毁后，就可以重新使用这部分内存来构造其他元素，或将其归还给系统

4. 拷贝和填充未初始化内存的算法

操作	说明
uninitialized_copy(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)	拷贝n个元素到b开始的内存中

5. 示例

	allocator<int> alloc;
	auto const p = alloc.allocate(10);
	auto q = p;
	alloc.construct(q++, 1);
	alloc.construct(q++, 2);
	while (q != p)
		alloc.destroy(--q);
	alloc.deallocate(p, 10);

　　假定有一个int的vector，希望将其内容拷贝到动态内存中。我们将分配一块比vector中元素所占空间大一倍的动态内存，然后将原vector中的元素拷贝到前一半空间，对后一半空间用一个给定值进行填充。

	vector<int> vec = {1, 2, 3, 4, 5};
	allocator<int> alloc;
	//分配比vec中元素所占用空间大一倍的动态内存
	int *p = alloc.allocate(vec.size() * 2);
	//通过拷贝vec中的元素来构造从p开始的元素
	auto q = uninitialized_copy(vec.begin(), vec.end(), p);
	//将剩余的元素初始化为42
	uninitialized_fill_n(q, vec.size(), 42);

6. 用allocator重写new中的程序

void func()
{
	allocator<string> a;
	auto const pa = a.allocate(5);	//pa指向a分配的内存首部
	auto q = pa;
	string s;
	while (q != pa + 5 && cin >> s) {
		a.construct(q++, s);
	}
	//q指向最后构造的元素之后的位置
	while (q != pa) {
		--q;
		cout << *q << endl;
		a.destroy(q);		//销毁元素
	}
	a.deallocate(pa, 5); 	//释放内存
}