RT
#include <iostream> using namespace std; template <class T> 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<T> 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 <class T> void Vec<T>::create() { data=avail=limit=0; } template <class T> void Vec<T>::create(size_type n,const T&val) { data = alloc.allocate(n); limit = avail = data+n; uninitialized_fill(data,limit,val); } template <class T> void Vec<T>::create(const_iterator i,const_iterator j) { data= alloc.allocate(j-i); limit = avail = uninitlized_copy(i,j,data); } //析构函数 template <class T> void Vec<T>::uncreate() { 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>::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 <class T> void Vec<T>::unchecked_append(const T& val) { alloc.construct(avail++,val); }