allocator class

当分配一大块内存时，我们通常计划在这块内存上按需构造对象，这样的我们希望将内存分配和对象构造分离。但是通常的new关键字的分配的动态空间，有时候会造成一些浪费，更致命的是“如果一个类没有默认构造函数，那么这个类就不能动态分配数组了”。

这时我们需要一个能将内存分配和对象构造分离的机制，allocator很好地帮助我们解决了这个问题。

#include 《memory》，allocator提供了一种类型感知的内存分配方法，它分配的内存是原始的，未构造的。我们可以利用allocator提供的操作对这些内存进行操作，

allocator<T> a	定义了一个名为a的allocator对象，它可以为类型为T的对象分配内存
a.allocator(n)	先定义，后分配。这分配一段原始的，未构造的，保存n个类型为T的对象；----》可以看出alllocator方法分配内存，也是先定义类型，在分配类型的数量
a.deallocat(p,n)	note，在此操作之前，必须堆每个在这个内存中创建的对象调用destory方法。 释放从T*,这块内存保存了n类型为T的对象,p必须是一个先前由allocator返回的指针.且n必须是p创建时所要求大小,在调用deallocator之前,用于必须堆每个在这块内存中创建的对象调用destroy方法
a.construct(p,args)	p必须是一个T*的指针,指向一个块原始内存,args被传递给类型为T的构造函数,用在在p指向的内存中构造一个对象
a.destroy(p)	p为类型为T*的指针,此方法堆p所指对象执行析构函数

allocator<string> alloc;
auto const p = alloc.allcoate(n);

auto q = p;
alloc.construct(q++);//*q is a null string
alloc.construct(q++,,'c')// *q is cccccccccc
alloc.construct(q++,"hi")//*q is hi

在未构造对象的情况下,就使用原始内存是错误的
例如
cout<<*p<<endl;
cout<<*q<<endl;//这个是非法的

记住,为了使用allcocate返回的内存,我们必须用construct构造对象,使用未构造的函数,其行为是未定义的.
党我们使用完对象后,必须堆每个构造函数调用destroy来销毁
while(q!=p){
  alloc.destroy(--q);
}//我们只能堆真正构造了的元素进行destroy操作

//一旦元素被销毁后,我们重新使用这部分内存来保存其他string,
//也可以将内存归还给os,释放内存是通过deallocate(p,n)来完成的

alloc.deallocate(p,n);

拷贝/填充未初始化的算法,STL还定义了两个伴随算法,可以在未初始化内存中创建对象

uninitialized_copy(b,e,b2)	从迭代器b和e指出的输入范围拷贝元素到迭代器b2指定的未构造的原始原始内存中,b2指向的内存必须足够大,能容纳输入序列中元素的拷贝
uninitiated_copy(b,n,b2)
uninitiated_fill(b,e,t)	在迭代器b和e指定的原始内存范围中创建对象,对象的值均为t的拷贝
uninitiated_fill(b,n,t)

/*
假定有一个例子,希望将其内容拷贝到动态内存中,我们将分配一块比vector中元素空间大一倍的动态内存,然后将原vector中的元素拷贝到前一半空间,后一半空间利用一个给定值进行填充
*/

auto p = alloc.allocate(vi.size()*);

auto q = uninitiated_copy(vi.begin(),vi.end(),p);

uninitiated_fill(q,vi.size(),);

test case

 #ifndef STRVEC_H_INCLUDED
 #define STRVEC_H_INCLUDED
 #include<vector>
 #include<string>
 #include<memory>
 #include<utility>
 #include<iostream>
 /**
 这里要实现的是一个STLvector的简化版,只能运用于string,由于没有template.
 设计思路:
 1,预先分配足够大的内存来保存可能需要的更多的元素,
 2,当StrVec添加每个元素时,成员函数chk_n_alloc()会检查是否有足够空间容纳更多的元素
   2.1 如果有,alloc.construct()会在下一个可用位置构造一个对象
   2.2 如果没有,StrVec会充分分配空间alloc_n_copy(),并且拷贝一个给定范围中的元素,然后释放掉旧的空间free()
         并添加新的元素

         ---------------------------------------------
         |   |   |   |   |                           |
         ---------------------------------------------
         ^                 ^                           ^
         elements          first_free                  cap
         --
 每个StrVec有三个指针指向其元素所使用的内存:
 elements,指向分配中的首元素
 frist_free,指向最后一个实际元素位置之后的位置
 cap,指向分配的内存末尾之后的位置
 ------------------

 StrVec除了指出位置的指针外,还有名为alloc的静态成员,类型为allocator<string>,它分配我们所需要的内存
 ---
 另外还有4个工具函数,
 alloc_n_copy(),分配内存并拷贝一个给定范围中的元素
 free()//销毁构造的元素病释放内存
 chk_n_alloc()//保证StrVec至少能容纳一个新元素的空间,如果没有空间添加新元素,chk_n_alloc会调用reallocate()来分配更多的空间按
 reallocate()//在内存使用完后,reallocate()重新分配元素

 */

 using namespace std;
 class StrVec{
 public:
     StrVec():elements(nullptr),first_free(nullptr),cap(nullptr){}///构造函数,对成员进行初始化
     StrVec(const StrVec&);///拷贝构造函数,从无到有
     StrVec &operator=(const StrVec &);///拷贝赋值运算符=,对存在的元素赋予新值
     ~StrVec();///析构函数

     void push_back(const std::string&);///拷贝元素

     size_t size() const {return first_free - elements;}///返回StrVec中的元素个数
     size_t capacity() const {return cap - elements;}///返回StrVec中实际分配的(可以容纳类型元素的)内存大小
     string *begin() const {return elements;}///返回首元素
     string *end() const {return first_free;}///返回StrVec末尾元素的后一个位置

 private:
     static allocator<string> alloc;///分配元素,注意是静态成员
     void chk_n_alloc(){///被添加元素的函数使用
         if(size() == capacity())
             reallocate();
     }///
     ///工具函数，被拷贝构造函数，赋值运算符和析构函数使用
     pair<string*,string*> alloc_n_copy(const string*,const string*);///什么时候没有空间容纳新元素呢? first_free==cap的时候.
     void free();///撤销元素病释放内存
     void reallocate();///获得更多内存并且拷贝已有元素

     string *elements;///指向数组首元素的指针
     string *first_free;///指向数组第一个空闲元素的指针
     string *cap;///指向数组尾后位置的指针
 };

 void show();

 #endif // STRVEC_H_INCLUDED

----

 #include "StrVec.h"
 using namespace std;

 allocator<string> StrVec::alloc;

 void show(){
     std::cout<<"from StrVec.cpp"<<std::endl;
 }

 void StrVec::push_back(const string& s){
     chk_n_alloc();///

     alloc.construct(first_free++,s);
 }

 ///函数返回一个pair,两个指针分别指向新空间的开始位置和拷贝的尾后位置,即data是新空间开始的位置,uninitiated_copy()返回新空间拷贝的尾后位置
 pair<string*, string*>
 StrVec::alloc_n_copy(const string *b,const string *e){
     auto data = alloc.allocate(e-b);
     return make_pair(data,uninitialized_copy(b,e,data));
     //return {data,unintialized_copy(b,e,data)};
 }

 void StrVec::free(){
     ///can not pass a nullptr to deallocate(),if elements is 0,then free() do nothing
     if(elements){
         for(auto p = first_free;p != elements;/* */){
             StrVec::alloc.destroy(--p);
         }
         StrVec::alloc.deallocate(elements,cap-elements);
     }
 }

 StrVec::StrVec(const StrVec &s){
     auto newdata = alloc_n_copy(s.begin(),s.end());
     elements = newdata.first;
     first_free = newdata.second;
     cap = newdata.second;
 }

 StrVec::~StrVec(){
     free();
 }

 StrVec &StrVec::operator=(const StrVec &rhs){
     ///
     auto data = alloc_n_copy(rhs.begin(),rhs.end());
     free();///释放掉已有元素之前,调用alloc_n_copy缓存rhs的元素,这可以处理自我赋值
     elements = data.first;
     first_free = data.second;
     cap = data.second;

     return *this;///
 }

 /**
 在重新分配内存的过程中移动而不是拷贝元素
 我们reallocate()应该做些什么呢?
 1,为一个新的,更大的string数组分配元素
 2,在内存空间的前一部分构造,保存现有元素
 3,销毁原来内存空间中的元素,并释放这块内存
 */

 void StrVec::reallocate(){
     auto newcapacity = size() ? *size():;

     auto newdata = StrVec::alloc.allocate(newcapacity);

     auto dest = newdata;
     auto elem = elements;

     for(size_t i = ;i != size();i++){
         StrVec::alloc.construct(dest++,std::move(*elem++));
     }

     free();

     elements = newdata;
     first_free = dest;
     cap = elements + newcapacity;
 }

-----main.cpp

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include "StrVec.h"
using namespace std;

int main()
{
    show();
    StrVec sv;
    sv.push_back("aaa");
    sv.push_back("bbb");

    int length = sv.size();
    string *ptr = sv.begin();
    for(int i = ;i<length;i++){
        cout<<*ptr++<<endl;
    }

    StrVec svb(sv);
    string *ptrb = svb.begin();
    for(int i = ;i<svb.size();i++){
        cout<<*ptrb++<<endl;
    }

    StrVec svc = sv;
    string *ptrc = svb.begin();
    for(int i = ;i<svc.size();i++){
        cout<<*ptrc++<<endl;
    }
    return ;
}

================