c++ vector重写

对C++ vector容器重写

头文件

#ifndef _vec_h
#define _vec_h

#include
#include
//#include

template class Vec{
public:
	typedef T* iterator;
	typedef const T* const_iterator;
	typedef size_t size_type;

	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];}
	
	iterator begin() {return data;	}
	const_iterator begin() const{return data;	}
	iterator end() {return avail;	}
	const_iterator end() const {return avail;	}
	size_type size() const{return avail-data;}
	void push_back(const T&);

private:
	iterator data,avail,limit;
	std::allocator alloc;
	
	void create();
	void create(size_type,const T&);
	void create(const_iterator,const_iterator);
	void uncreate();
	void grow();
	void unchecked_appended(const T&); 
};

#endif

template  void Vec::create(){
	data=avail=limit=0; 
}

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

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

template  void Vec::uncreate(){
	if(data){
	  iterator i=avail;
	  while(i!=data)
	    alloc.destroy(--i);
	  alloc.deallocate(data,limit-data);
	}
	data=avail=limit=0; 
	
}

template  void Vec::grow(){
	size_type maxlen;
	maxlen=std::max(2*(limit-data),ptrdiff_t(1));            //确定vector容量
	
	iterator new_data,new_avail;
	new_data=alloc.allocate(maxlen);                    //申请未初始化的内存空间 
	new_avail=std::uninitialized_copy(data,avail,new_data);       //拷贝工作 
	uncreate();                                             //删除工作 
	data=new_data;
	avail=new_avail;
	limit=data+maxlen;                               //更新limit 
}

template  void Vec::unchecked_appended(const T& v){
	alloc.construct(avail++,v);                             //特别注意这里在未初始化的内存中构造v对象 
}

template  Vec& Vec::operator=(const Vec& v){
	if(&v != this){
		uncreate();
		create(v.begin(),v.end());
	}
	return *this;
}

template  void Vec:: push_back(const T& v){
	if(avail==limit)
		grow();
	unchecked_appended(v);	
	
}

测试例程

#include"vec.h"

#include

using namespace std;

int main(){
	Vec v;
	
	cout<::iterator i;
	for(i=v.begin();i!=v.end();i++)
	  cout<< *i <<"\t";
	cout< v1=v;
	for(i=v1.begin();i!=v1.end();i++)
	  cout<< *i <<"\t";
	cout< v3(v);
	for(i=v3.begin();i!=v3.end();i++)
	  cout<< *i <<"\t";
	cout<