自己创建一个新的Vec类用来实现vector的功能

RT

#include 
using namespace std;

template  class Vec{
public:
	typedef T* iterator;
	typedef const T* const_iterator;
	typedef size_t size_type;
	typedef T value_type;
	typedef T& reference;
	typedef const T& const_reference;

	Vec() {create();}
	explicit Vec(size_type n,const T& t=T()){create(n,t);}
	Vec(const Vec&v){create(v.begin(),v.end());}
	Vec& operator=(const Vec&);
	~Vec(){uncreate();}

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

	void push_back(const T& t){
		if(avail == limit)
		{
			grow();
		}

		unchecked_append(t);
	}

	size_type size() const {return avail - data;}

	iterator begin(){return data;}
	const_iterator begin() const{return data;}

	iterator end() {return avail;}
	const_iterator end() const{return avail;}

private:
	iterator data;
	iterator avail;
	iterator limit;

	allocator alloc;
	void create();
	void create(size_type,const T&);
	void create(const_iterator,const_interator);

	void uncreate();

	void grow();
	void unchecked_append(const T&);
};

//构造函数
template  void Vec::create()
{
	data=avail=limit=0;
}

template  void Vec::create(size_type n,const T&val)
{
	data = alloc.allocate(n);
	limit = avail = data+n;
	uninitialized_fill(data,limit,val);
}

template  void Vec::create(const_iterator i,const_iterator j)
{
	data= alloc.allocate(j-i);
	limit = avail = uninitlized_copy(i,j,data);
}

//析构函数
template  void Vec::uncreate()
{
	if(data)
	{
		iterator it = avail;
		while(it!=data)
			alloc.destroy(--it);
		alloc.deallocate(data,limit-data);
	}
	data=limit=avail=0;
}

//
template  void Vec::grow()
{
	size_type new_size = max(2*(limit-data),ptrdiff_t(1));

	iterator new_data = alloc.allocate(new_size);
	iterator new_avail = uninitialized_copy(data,avail,new_data):

	uncreate();

	data=new_data;
	avail = new_avail;
	limit = data+new_size;
}

template  void Vec::unchecked_append(const T& val)
{
	alloc.construct(avail++,val);
}