vector.h

班级通讯录c++编写

#include <iostream.h>
#include <assert.h>
//
template <class t>class vector
{
public:
	vector(unsigned num);
	vector(unsigned num,t val);
	vector(const vector<t> & source);
	virtual ~vector();
	t& operator[](unsigned index)const;
	vector<t>& operator=(const vector<t>&);
	unsigned length()const;
	unsigned setsize(unsigned numof);
	unsigned setsize(unsigned unmof,t val);
	unsigned grow(unsigned nun);
	unsigned shrink(unsigned num);
	friend ostream & operator<<(ostream &,vector<t>&);
protected:
	t* data;
	unsigned size;
};
template<class t>vector<t>::vector(unsigned num):size(num)
{
	data=new t[size];
	assert(data!=0);
}
template <class t> vector<t>::vector(unsigned num,t v)
:size(num)
{
	data=new t[size];
	assert(data!=0);
	//
	for(unsigned i=0;i<size;i++)
		data[i]=v;
}
template<class t> vector<t>::vector(const vector<t> & s)
:size(s.size)
{
	data=new t[size];
	assert(data!=0);
	//
	for(int i=0;i<size;i++)
		data[i]=s.data[i];
}
//
template <class t> vector<t>::~vector()
{
	//
	delete[] data;
	data=0;
	size=0;
}
template<class t>t & vector<t>::operator []
(unsigned index)const
{
	assert(index<size);
	return data[index];
}
template <class t>unsigned vector<t>::length()const
{
	return size;
}
template<class t>unsigned vector<t>::setsize (unsigned num)
{
	if(size !=num)
	{
		t * np=new t[num];
		assert(np!=0);
		unsigned n=num<=size ? num:size;
		for(int i=0;i<n;i++)
			np[i]=data[i];
		delete[]data;
		size=num;
		data=np;
	}
	return size;
}
template <class t>unsigned 
vector<t>::grow (unsigned num)
{
	unsigned n=size+num;
	t *np=new t[n];
	for(unsigned i=0;i<size;i++)
		np[i]=data[i];
	delete[]data;
	size=n;
	data=np;
}
template <class t>unsigned
vector<t>::shrink (unsigned num)
{
	if(size<=num)
	{
		size=0;
		delete[]data;
	}
	else
	{
		unsigned n=size-num;
		t *np=new t[n];
		for(unsigned i=0;i<n;i++)
			np[i]=data[i];
		delete[]data;
		size=n;
		data=np;
	}
}

template <class t>vector<t> & vector<t>::operator =
(const vector<t>& right)
{
	if(size!=right.size)
	{
		t* np=new t[right.size];
		assert(np!=0);
		delete[]data;
		size=right.size;
		data=up;
	}
	for(int i=0;i<size;i++)
		data[i]=right.data[i];
	return *this;
}
ostream & operator<<(ostream & out,vector<float> & fv)
{
	for(unsigned i=0;i<fv.size;i++)
		out<<fv[i];
	return out;
}
//

 //遍历器
template <class t>class iterator
{
	public:
		//
		virtual int init()=0;
		//
		virtual int operator!()=0;
		//
		virtual t operator()()=0;
		//
		virtual int operator++()=0;
		//
		virtual void operator=(t newvalue)=0;
};



//向量遍历器
template <class t>class vectoriterator:public iterator<t>
{
	public:
		//
		vectoriterator(vector<t>&);
		vectoriterator(const vectoriterator &);
		//
		virtual int init();
		virtual t operator()();
		virtual int operator!();
		virtual int operator++();
		virtual void operator=(t newvalue);
		//
		int operator--();
		int key();
	protected:
		//
		unsigned currentkey;
		vector<t>& data;
};
template<class t>vectoriterator<t>::vectoriterator
(vector<t> & v):data(v)
{
	init();
}
template <class t>int vectoriterator<t>::init()
{
	currentkey=0;
	return operator!();
}
template <class t>vectoriterator<t>::
vectoriterator(const vectoriterator<t> & x)
:data(x.data),currentkey(x.currentkey)
{
}

template <class t>int vectoriterator<t>::operator ! ()
{
	 return currentkey<data.length();
}
template <class t> int vectoriterator<t>::operator ++()
{
	currentkey++;
	return operator !();
}
template <class t>t vectoriterator<t>::operator ()()
{
	return data[currentkey];
}
template <class t>
void vectoriterator<t>::operator =(t newvalue)
{
	data[currentkey]=newvalue;
}
template<class t>
int vectoriterator<t>::operator --()
{
	if(currentkey>0)
		currentkey--;
	return operator!();
}
template <class t>int vectoriterator<t>::key ()
{
	return currentkey;
}