list.h

班级通讯录c++编写

template<class T>class list;
template<class T>class listIterator;
template<class T>class iterator;
template<class T>class link{
	public:
		link<T>*insert(T val);       
	private:
		link(T linkValue,link<T>* nextPtr);
		link(const link<T>& source);
		link<T>*duplicate()const;
		T value;
		link<T>* ptrToNextLink;
		friend class list<T>;
		friend class listIterator<T>;
      
};
template<class T>link<T>::link(T val ,link<T>*nxt):value(val),ptrToNextLink(nxt){}
template<class T>link<T>::link(const link<T> &source):value(source.val),ptrToNextLink(source.ptrToNextLink){}
template<class T>link<T>*link<T>::insert(T val){
	ptrToNextLink=new link<T>(val,ptrToNextLink);
	assert(ptrToNextLink!=0);
	return ptrToNextLink;
}
template<class T>link<T>*link<T>::duplicate()const{
	link<T>*newlink;
	if(ptrToNextLink!=0)
		newlink=new link<T>(value,ptrToNextLink->duplicate());
	else
		newlink=new link<T>(value,0);
	assert(newlink!=0);
	return newlink;
}
template<class T>class list{
	public:
		list();
		list(const list<T> &source);
		virtual ~list();
		virtual void add(T value);
		virtual void deleteAllValues();
		T firstElement()const;
		virtual int includes(T value)const;
		int isEmpty()const;
		virtual void removeFirst();
		list<T>*duplicate()const;
		friend class polynomial;
		void operator=(const list<T> & right);
	protected:
		link<T> *ptrToFirstLink;
		friend class listIterator<T>;
};
template <class T>list<T>::list():ptrToFirstLink(0){}
template <class T>int list<T>::isEmpty()const{
	return ptrToFirstLink==0;
}
template <class T>void list<T>::add(T val){
	ptrToFirstLink=new link<T>(val,ptrToFirstLink);
	assert(ptrToFirstLink!=0);
}
template <class T>T list<T>::firstElement()const{
	assert(ptrToFirstLink!=0);
	return ptrToFirstLink->value;
}
template <class T> void list<T>::removeFirst(){
	assert(ptrToFirstLink!=0);
	link<T>*p=ptrToFirstLink;
	ptrToFirstLink=p->ptrToNextLink;
	delete p;
}
template <class T> int list<T>::includes(T v)const{
	for(link<T>*p=ptrToFirstLink;p;p=p->ptrToNextLink)
		if(v==p->value)return 1;
		return 0;
}
template <class T> void list<T>::deleteAllValues(){
	link<T>* next;
	for(link<T>*p=ptrToFirstLink;p!=0;p=next){
		next=p->ptrToNextLink;
		p->ptrToNextLink=0;
		delete p;
	}
	ptrToFirstLink=0;
}
template <class T>list<T>*list<T>::duplicate()const{
	list<T>*newlist=new list<T>;
	assert(newlist!=0);
	if(ptrToFirstLink)
		newlist->ptrToFirstLink=ptrToFirstLink->duplicate();
	return newlist;
}
template <class T> list<T>::list(const list<T> &source){
	if(source.isEmpty())
		ptrToFirstLink=0;
	else
	{
		link<T>*firstLink=source.ptrToFirstLink;
		ptrToFirstLink=firstLink->duplicate();
	}
}
template <class T> void list<T>::operator=(const list<T> & right){
	deleteAllValues();
	ptrToFirstLink=right.duplicate()->ptrToFirstLink;
	delete right.duplicate()->ptrToFirstLink;
}
template <class T> list<T>::~list(){
	deleteAllValues();
}

template<class T> class listIterator:public iterator<T>{
	public:
		listIterator(list<T>&aList);
		//listIterator(dictionaryList<T>&aList);
		virtual int init();
		virtual T operator()();
		virtual int operator!();
		virtual int operator++();
		virtual void operator=(T value);
		void removeCurrent();
		void addBefore(T newValue);
		void addAfer(T newValue);
		void operator=(listIterator<T>&);
	protected:
		link<T>*currentLink;
		link<T>*previousLink;
		list<T>& theList;
};
template<class T>void listIterator<T>::operator=(listIterator<T>&right){
	theList=right.theList;
	currentLink=right.currentLink;
	previousLink=right.previousLink;
}
template<class T>listIterator<T>::listIterator(list<T> & aList):theList(aList){
	init();
}
template<class T>int listIterator<T>::init(){
	previousLink=0;
	currentLink=theList.ptrToFirstLink;
	return currentLink!=0;
}
template<class T> T listIterator<T>::operator ()(){
	assert(currentLink!=0);
	return currentLink->value;
}
template<class T>void listIterator<T>::operator =(T val){
	assert(currentLink!=0);
	currentLink->value=val;
}
template<class T> void listIterator<T>::removeCurrent(){
	assert(currentLink!=0);
	if(previousLink==0)
		theList.ptrToFirstLink=currentLink->ptrToNextLink;
	else
		previousLink->ptrToNextLink=currentLink->ptrToNextLink;
	delete currentLink;
	currentLink=0;
}
template<class T>int listIterator<T>::operator ++(){
	if(currentLink==0)
	{
		if(previousLink==0)
			currentLink=theList.ptrToFirstLink;
		else
			currentLink=previousLink->ptrToNextLink;
	}
	else{
		previousLink=currentLink;
		currentLink=currentLink->ptrToNextLink;
	}
	return currentLink!=0;
}
template<class T>int listIterator<T>::operator !(){
	if(currentLink!=0)
		return 1;
	if(previousLink!=0)
		return previousLink->ptrToNextLink!=0;
	return theList.ptrToFirstLink!=0;
}
template<class T>void listIterator<T>::addBefore(T val){
	if(previousLink)
		previousLink=previousLink->insert(val);
	else
	{
		theList.list<T>::add(val);
		previousLink=theList.ptrToFirstLink;
	}
}
template<class T>void listIterator<T>::addAfer(T val)
{
	if(currentLink!=0)
		currentLink->insert(val);
	else if(previousLink!=0)
		previousLink->insert(val);
	else theList.list<T>::add(val);
}