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() ? 2 * size() : 1;
    auto newdata = alloc.allocate(newCapacity);

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

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

}