模拟实现list(迭代器)

#pragma  once;
#include <assert.h>
#include<iostream>
#include <assert.h>
using namespace std;
template<class T>
struct __ListNode
{
     T  _data;
	 __ListNode<T>* _next;
	 __ListNode<T>* _prev;
	  __ListNode(const T& x)
		  :_data(x)
		  ,_next(NULL)
		  ,_prev(NULL)
	  {
	  }
};
template <class T,class Ref,class Ptr >
struct __ListIterator
{
	typedef  __ListNode<T>   Node;
    typedef  __ListIterator<T,Ref,Ptr> Self;
__ListIterator(Node* node)   
		:_node(node)
	{
	}
	Ref  operator*()
	{
	    return _node->_data;
	}
	Ptr  operator->()
	{
	    return &(_node->_data)
	}
	Self& operator++()
	{
	   _node=_node->_next;
	   return *this;
	}
	Self& operator--()
	{
		_node=_node->_prev;
		return *this;
	}
	Self operator++(int)
	{
		Self tmp=_node;
		_node=_node->_next;
		//return tmp;
		return Self(tmp)   
	}
	Self  operator--(int)
	{   
		Self tmp=(*this);
		_node=_node->_prev;
		return tmp;
	}
	bool operator!=(const Self& s) const
	{
	 return this->_node!=s._node;
	}
	bool operator==(const Self& s) const
	{
		return this->_node==s._node;
	}
	Node* _node;
};
template<class T>
struct List
{
    typedef  __ListNode<T> Node;
public:
	typedef  __ListIterator<T,T&,T*> Iterator;
	typedef  __ListIterator<T,const T&,const T*> ConstIterator;
	Node* GetNode(const T& x)
	{
		return new Node(x);
	}
	List()
	{
       _head=GetNode(T());
	   _head->_next=_head;
	   _head->_prev=_head;
	}
	Iterator Begin()
	{
	  return Iterator(_head->_next);
	}
	Iterator End()
	{
	  return Iterator(_head);
	}
	ConstIterator Begin() const
	{
		return ConstIterator(_head->_next);
	}
	ConstIterator End() const
	{
		return ConstIterator(_head);
	}
	 
	void PushBack(const T& x)
	{
	  /*  Node* _tail=_head->_prev;
		Node* tmp=GetNode(x);
		_tail->_next=tmp;
		tmp->_prev=_tail;
		tmp->_next=_head;
		_head->_prev=tmp;*/
		Insert(End(),x);
	}
  void PopBack()
  {
	 /* assert(_head->_prev );
      Node* tail=_head->_prev;
	  Node* prev=tail->_prev;
	  Node* next=tail->_next;
	  prev->_next=next;
	  next->_prev=prev;
	  delete tail;*/
	  Erase(--End());
  }
  void PushFront(const T& x)
  {
    /*assert(_head)
	  Node* tmp=GetNode(x);
      Node* next=_head->_next;

	  _head->_next=tmp;
	  tmp->_prev=_head;

	  tmp->_next=next;
       next->_prev=tmp;*/
	  Insert(Begin(),x);
  }
  void PopFront()
  {
	  /*assert(_head->_next);
     Node* tmp=_head->_next;
	 Node* next=tmp->_next;

     _head->_next= next;
	 next->_prev=_head;
	 delete tmp;*/

       Erase(Begin());
  }
 Iterator Insert(Iterator pos, const T& x)
 {
     assert(pos._node);
	 Node* tmp=GetNode(x);
	 Node* cur=pos._node;
	 Node* prev=cur->_prev;
	   
	 prev->_next=tmp;
	 tmp->_prev=prev;
	 tmp->_next=cur;
	 cur->_prev=tmp;
	 return  tmp;
 }
 Iterator  Erase(Iterator pos)
{
assert(pos._node && pos._node!=NULL);
Node* tmp=pos._node;
Node* next=tmp->_next;
Node* prev=tmp->_prev;
  
next->_prev=prev;
prev->_next=next;

delete tmp;
return Iterator(next);
}
 
protected:
	Node* _head;
};
void PrintList(const List<int>& l)
{
	List<int>::ConstIterator It=l.Begin();
	while(It!=l.End())
	{ 
	   cout<<*It<<" ";
	   ++It;
	}
	cout<<endl;}
 void TestList2()
{
	List<int> l2;
	
	l2.PushBack(1);	 
	l2.PushBack(2);
	l2.PushBack(3);
	l2.PushBack(4);
   l2.PopBack(); 
    l2.PopBack(); 
	 l2.PopBack(); 
	  l2.PopBack(); 
	   l2.PopBack(); 
	PrintList(l2);
}
void TestList3()
{
	List<int> l3;
	l3.PushFront(1);
	l3.PushFront(2);
	l3.PushFront(3);
	l3.PushFront(4);
	l3.PopFront();
	l3.PopFront();
	l3.PopFront();
	PrintList(l3);
 
}

#include "List.h"

int main()
{
	//TestList1();
     //TestList2();
	  TestList3();  
	return 0;
}