[C++] 空间配置器——allocator类

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