Acclerate C++ 定义抽象数据类型（仿写STL中的Vector）

Vec.h 

#include<algorithm>
#include<memory>
template <class T>
class Vec
{
public:
	typedef T* iterator;
	typedef const T* const_iterator;
	typedef size_t size_type;
	typedef T value_type;
	Vec& operator=(const Vec&);
	Vec(const Vec& v) { create1(v.begin(), v.end()); };//复制构造函数
	Vec() { create1(); };  //构造函数
	explicit Vec(size_type n, const T& val = T()) { create1(n, val); }//构造函数
	~Vec() { uncreate1(); } //析构函数


	size_type size() const { return limit - data; }
	T& operator[](size_type i) { return data[i]; }
	const T& operator[](size_type i) const { return data[i]; }

	iterator begin() { return data; }
	const_iterator begin() const { return data; }
	iterator end() { return limit; }
	const_iterator end() const { return limit; }
	template<class T>
	void push_back(const T& val) {
		if (avail == limit)//获得需要的空间
		{
			grow1();
		}
		unchecked_append1(val); //将新增元素添加到对象末端
	}

private:
	iterator data;//首元素
	iterator avail;
	iterator limit;//末元素

	std::allocator<T> alloc;

	void create1();
	void create1(size_type, const T&);
	void create1(const_iterator, const_iterator);

	void uncreate1();

	void grow1();
	void unchecked_append1(const T&);


};

template<class T>
Vec<T>& Vec<T>::operator=(const Vec& rhs)
{
	// TODO: 在此处插入 return 语句
	//判断是否是自我赋值
	if (&rhs != this)
	{
		//删除运算符左侧的数组
		uncreate1();
		//从右侧元素复制到左侧
		create1(rhs.begin(), rhs.end());
	}
	return *this;
}

//默认构造函数
template<class T>
void Vec<T>::create1()
{
	data = avail = limit = 0;
}
//带参数的构造函数
template<class T>
void Vec<T>::create1(size_type n, const T & val)
{
	data = alloc.allocate(n);
	limit = avail = data + n;
	std::uninitialized_fill(data, limit, val);
}
template<class T>
void Vec<T>::create1(const_iterator i, const_iterator j)
{
	data = alloc.allocate(j - i);
	limit = avail = std::uninitialized_copy(i, j, data);
}

template<class T>
void Vec<T>::uncreate1()
{
	if (data)
	{   //以相反的顺序删除构造函数生成的元素
		iterator it = avail;
		while (it != data)
		{
			alloc.destroy(--it);
		}
		//返回占用的所有内存空间
		alloc.deallocate(data, limit - data);
	}
	data = limit = avail = 0;
}
template<class T>
void Vec<T>::grow1()
{
	//为对象分配实际使用的2倍的内存
	size_type new_size = std::max(2 * (limit - data), ptrdiff_t(1));
	//分配新的内存空间并将已存在的元素对象内容复制到新空间
	iterator new_data = alloc.allocate(new_size);
	iterator new_avail = std::uninitialized_copy(data, avail, new_data);
	//返回原来的内存空间
	uncreate1();
	//重置指针，使其指向新分配的内存空间
	data = new_data;
	avail = new_avail;
	limit = data + new_size;
}

template<class T>
//假设avail指向一片新分配但尚未被初始化的内存空间
void Vec<T>::unchecked_append1(const T& val)
{
	alloc.construct(avail++, val);
}