1、new和delete有一些灵活性上的局限：new把内存分配和对象构造组合在了一起；delete将对象析构和内存释放组合在了一起。
2、当分配一大块内存时，我们通常计划在这块内存上按需构造对象，在此情况下，我们希望将内存分配和对象构造分离；这意味着我们可以分配大块内存，但只在真正需要的时候才真正执行对象创建操作。
3、allocator类，定义在头文件memory中，它帮助我们将内存分配和对象构造分离开来，它提供一种类型感知的内存分配方法，它分配的内存是原始的、未构造的。在分配内存时，它会根据对象类型来确定恰当的内存大小和对齐位置。
4、allocator类中的算法
#ifndef _ALLOCATOR_H_
#define _ALLOCATOR_H_ #include<memory>
#include<string>
#include<iostream>
#include<vector>
using namespace std;
class Allocator { //这个是自己命名的类
public:
/**
* 内存分配练习
* allocate(n)，分配大小为n未初始化空间；
* construct(q),对q指向的空间进行默认初始化；construct(q,"j"),对q指向的空间初始化为"j",只要是合法的初始化器就可以；
* destroy(q),对q指向的对象进行析构
* deallocate(p,n),释放原始分配的空间，必须先把内存中的对象全部析构，然后全部释放，不能只释放一部分
*/
void allocator_test(const int &n) {
allocator<string>alloc;
auto p = alloc.allocate(n);//分配保存n个string的原始内存
auto q = p;
while (q != p + n) {
alloc.construct(q++, "zhizhiyu");//构造n个string
}
cout << "构造的第一个string是："<<*(p) << endl;
while (q != p) {
alloc.destroy(--q);//对分配的对象进行析构
}
alloc.deallocate(p, n);//释放内存
}
/**
* 拷贝和填充原始内存,allocate,deallocate,
* uninitialized_copy(b,e,b2),向原始空间b2中拷贝由b和e指定范围的元素，返回递增之后的目的位置寄存器，指向下一个未构造的位置
* uninitialized_copy_n(b,n,b2),向原始空间b2中拷贝由b开始的n个元素，返回递增之后的目的位置寄存器，指向下一个未构造的位置
* uninitialized_fill(b,e,t),b和e范围指定的原始内存用元素t填充，无返回值
* uninitialize_fill_n(b,n,t),b开始的n个原始内存空间用元素t填充，无返回值
*/
void alloc_copy_and_fill(const vector<int>&v) {
int n = v.size();
allocator<int> alloc;
auto p = alloc.allocate(n * );
auto q = uninitialized_copy(v.begin(), v.end(), p);//拷贝v到未初始化空间中
q = uninitialized_copy_n(v.begin(), n, q);//再把v拷贝一遍
uninitialized_fill(q, q + n, );//用22填上接下来n个空间
uninitialized_fill_n(q+n, n, );//剩余n个空间变为44
auto pq = q + *n;
while (pq != p) {
cout << *(--pq) << " ";
alloc.destroy(pq);
}
alloc.deallocate(p, n * );
}
}; #endif