vector实现（只能装入string）

 #include<iostream>
 #include<string>
 #include<memory>
 #include<utility>
 using namespace std;

 class StrVec {
 public:
     StrVec():element(nullptr),first_free(nullptr),cap(nullptr){}   // 默认构造函数
     StrVec(const StrVec&); //拷贝构造函数
     StrVec &operator=(const StrVec&); //赋值拷贝运算符
     ~StrVec();

     void push_back(const string&);

     size_t size() const {
         return first_free - element;
     }
     size_t capacity()const {
         return cap - element;
     }
     string *begin() const {
         return element;
     }
     string *end()const {
         return first_free;
     }

 private:
     static allocator<string> alloc;

     void chk_n_alloc() {
         if (size() == capacity())
             reallocate();
     }
     pair<string*, string*> alloc_n_copy(const string*, const string*);  // 用于被copy控制成员调用

     void free();
     void reallocate();  //获得另一块更大的内存(释放原有内存)并拷贝已有元素   （实现的是标准库vector的内存分配机制）
     string *element; // 数组首地址
     string *first_free;
     string *cap;

 };

 void StrVec::push_back(const string& s)
 {
     chk_n_alloc();
     alloc.construct(first_free++, s);
 }

 pair<string*, string*> StrVec::alloc_n_copy(const string *b, const string *e)
 {
     auto data = alloc.allocate(e - b);
     return { data,uninitialized_copy(b,e,data) };
 }

 void StrVec::free()
 {
     if (element) {
         for (auto p = first_free; p != element;)
             alloc.destroy(--p);
         alloc.deallocate(element, cap - element);
     }
 }

 StrVec::StrVec(const StrVec& s)
 {
     //调用alloc_n_copy分配空间以容纳与s中一样多的元素
     auto newdate = alloc_n_copy(s.begin(), s.end());
     element = newdate.first;
     first_free = newdate.second;
 }

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

 StrVec& StrVec::operator=(const StrVec& rhs)
 {
     auto data = alloc_n_copy(rhs.begin(), rhs.end());
     free();
     element = data.first;
     first_free = cap = data.second;
     return *this;
 }

 //在一个新的，更大的string数组分配内存
 //在内存空间的前一部分构造对象，保存现有元素
 //销毁原内存中的元素，并释放这块内存
 void StrVec::reallocate()
 {
     //分配当前大小两倍的内存空间
     auto newCapacity = size() ?  * size() : ;
     auto newdata = alloc.allocate(newCapacity);

     auto dest = newdata;  // 新内存首地址
     auto elem = element;  // 旧内存首地址

     for (size_t i = ; i != size(); ++i)
         alloc.construct(dest++, std::move(*elem++));        // 因为vector重新分配内存，会将原来的数据销毁，没必要拷贝，这里使用移动拷贝来提高效率
     free();
     element = newdata;
     first_free = dest;
     cap = element + newCapacity;

 }