一个简单的string容器实现

class StrVec {
public:
	StrVec() :elements(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 - elements; }
	size_t capacity()const { return cap - elements; }
	string *begin()const { return elements; }
	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*);//工具函数，被拷贝构造函数、赋值运算符和析构函数使用

	void free();
	void reallocate();
	string *elements;   //指向数组首元素指针
	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 (elements) {
		for (auto p = first_free; p != elements;)
			alloc.destroy(--p);
		alloc.deallocate(elements,cap-elements);
	}
}
StrVec::StrVec(const StrVec& s)
{
	auto newdata = alloc_n_copy(s.begin(),s.end());
	elements = newdata.first;
	first_free = cap = newdata.second;
}

StrVec::~StrVec() { free(); }
StrVec &StrVec::operator=(const StrVec &rhs)
{
	auto data = alloc_n_copy(rhs.begin(),rhs.end());//调用alloc_n_copy分配内存，大小与rhs中元素占用空间一样多
	free();
	elements = data.first;
	first_free = cap = data.second;
	return *this;
}
void StrVec::reallocate()
{
	auto newcapacity = size() ? 2 * size() : 1;
	auto newdata = alloc.allocate(newcapacity);//分配新内存
	auto dest = newdata;        //指向新数组中下一个空闲位置
	auto elem = elements;       //指向旧数组中下一个元素
	for (size_t i = 0; i != size(); ++i)
		alloc.construct(dest++,move(*elem++));
	free();  //移动完元素后就释放旧内存空间
	elements = newdata;  //更新数据结构，执行新元素
	first_free = dest;
	cap = elements + newcapacity;
}