星辰

版权声明：转载时请以超链接形式标明文章原始出处和作者信息及本声明
http://sundry.blogbus.com/logs/20177958.html

template<class T> class Iterator{
public:
 virtual int init()=0;
 virtual int operator ++(int)=0;
 virtual int operator !()=0;
 virtual T operator ()()=0;
 //virtual void operator =(T newvalue)=0;
};
template <class T> class  Link;
template<class T> class ListIterator;
template <class T> class List;
template <class T> class List{
public:
 List();
 void add(T value);
 List(const List<T>& source);
 void deleteAllvalue();
 List<T>* duplicate() const;
 virtual ~List(){
  deleteAllvalue();
 }
 virtual Link<T>* includes(T value) const;
private:
 Link<T>* p1stLink;
 friend class Link<T>;
 friend class ListIterator<T>;
};
template<class T> Link<T>* List<T>::includes(T value) const{
 for(Link<T>* p=p1stLink;p;p=p->pNextLink){
  if(p->value==value)
   return p;
 }
 return 0;
}
template<class T> void List<T>::add(T value){
p1stLink= new Link<T>(value,p1stLink);
}
template<class T> List<T>* List<T>::duplicate() const{
 List<T>* newlist;
 newlist = new List<T>;
 if(p1stLink)
  newlist->p1stLink=p1stLink->duplicate();
 else
  newlist->p1stLink=0;
 return newlist;
}
template<class T> List<T>::List():p1stLink(0){}
template<class T> List<T>::List(const List<T>& source){
 if(source.p1stLink)
  p1stLink=source.p1stLink->duplicate();
 else
  p1stLink=0;
}
template<class T> void List<T>::deleteAllvalue(){
 Link<T>* next;
 for(Link<T>* i=p1stLink;i;i=next){
  next = i->pNextLink;
  i->pNextLink=0;
  delete i;
 }
}
template <class T> class  Link{
public:
 Link<T>* insert(T value); 
private:
 Link(T linkValue,Link<T>* pNext);
 Link(const Link<T>& source);
 Link<T>* duplicate() const;

 T value;
 Link<T>* pNextLink;
 friend class List<T>;
 friend class ListIterator<T>;
};
template<class T> Link<T>* Link<T>::insert(T value){
  pNextLink=new Link(value,pNextLink); 
 return pNextLink;
}
template<class T> Link<T>* Link<T>::duplicate() const{
 Link<T>* newlink;
 if(pNextLink!=0)
 newlink= new Link<T>(value,pNextLink->duplicate());
 else
 newlink=new Link<T>(value,0);
 return newlink;
}
template<class T> Link<T>::Link(T linkValue,Link<T>* pNext):value(linkValue),pNextLink(pNext){
}
template<class T> Link<T>::Link(const Link<T>& source):value(source.value),pNextLink(source.pNextLink){
}

template<class T> class ListIterator: public Iterator<T>{
public:
 virtual int init();
 ListIterator<T>(List<T>& refList);
 virtual int operator ++(int);
 virtual int operator !();
 virtual T operator ()();
 virtual void operator =(T newvalue);

 int includes(T value);
 void addBefore(T value);
 void addAfter(T value);
 void removeCurrent();
private:
 Link<T>* currentLink;
 List<T>& source;
 Link<T>* previousLink;
};
template<class T> int ListIterator<T>::init(){
 currentLink = source.p1stLink;
 previousLink =0;
 return operator !();
}
template<class T> ListIterator<T>::ListIterator(List<T>& refList):source(refList){
init();
}
template<class T> int ListIterator<T>::operator ++(int){
 if(currentLink)
 {
  previousLink = currentLink;
  currentLink = currentLink->pNextLink;
 }
 else
 {
  if(previousLink){
   currentLink = previousLink->pNextLink;
  }
  else
  {

   currentLink = source.p1stLink;
  }
 }
 return operator !();
}
template<class T> int ListIterator<T>::operator !(){
 if(currentLink)
  return 1;
 else
 {
  if(previousLink)
   return previousLink->pNextLink!=0;
  else
   return source.p1stLink!=0;
 }
}
template<class T> T ListIterator<T>::operator ()(){
 if(!currentLink)
  throw 1;
 return currentLink->value;
}
template<class T> void ListIterator<T>::operator =(T newvalue){
 if(!currentLink)
  throw 1;
 currentLink->value=newvalue;
}
template<class T> void ListIterator<T>::addBefore(T value){
 if(previousLink){
  previousLink=previousLink->insert(value);
 }
 else{
  source.add(value);
  previousLink = source.p1stLink;
 }
}
template<class T> void ListIterator<T>::addAfter(T value){
 if(currentLink)
  currentLink->insert(value);
 else
  if(previousLink){
   previousLink->insert(value);
  }
  else
   source.add(value);
}

template<class T> void ListIterator<T>::removeCurrent(){
 if(!currentLink)
  throw 1;
 if(previousLink)
  previousLink->pNextLink=currentLink->pNextLink;
 else
  source.p1stLink = currentLink->pNextLink;
 delete currentLink;
 currentLink = 0;
}
template<class T> int ListIterator<T>::includes(T value){
 currentLink=source.includes(value);
 for(init();currentLink;operator ++(1)){
  if(currentLink->value==value)
   return 1;
 }
 return 0;
};
int main(){
 try{
  List<int> list;
  

  ListIterator<int> li(list);
  for(int i=0;i<9;i++){
   li.init();

   li.addAfter(i);
   cout<<i<<endl;
  }
  //012345678
  cout<<endl<<li.includes(8)<<"#"<<endl;
  cout<<li();
  //cout<<li();
 }
 catch(int err)
 {
  if(err=1)
   cout<<"错误，当前节点为空";
 }

getchar();
  return 0;
}