用迭代器实现list的各种功能

<span style="font-size:24px;">#include<iostream>
#include<cstdlib>
#include<list>
#include<cassert>
using namespace std;

template<class T>
struct _ListNode
{
	_ListNode* _prev;
	_ListNode* _next;
	T _data;
	_ListNode(const T& x)
		:_data(x)
		,_prev(0)
		,_next(0)
	{}
};

template<class T,class Ref,class Ptr>   //<T,T&,T*>
struct _ListIterator
{
	typedef _ListNode<T> Node;
	typedef _ListIterator<T,Ref,Ptr> Self;
	_ListIterator()
	{}
	_ListIterator(Node* node)
		:_node(node)
	{}
	Ref operator*()
	{
		return _node->_data ;
	}
	Ptr operator->()     //p->a==(*p).a
	{
		return _node;    //返回地址
	}
	bool operator==(const Self& s)
	{
		return _node ==s._node ;
	}
	bool operator!=(const Self& s)
	{
		return _node!=s._node  ;
	}
	Self& operator++()   //前置++
	{
		_node=_node->_next;
		return *this;
	}
	Self operator++(int)
	{
		Self tmp(_node);
		_node=_node->_next ;
		return tmp;
	}
	Self& operator--()
	{
		_node=_node->_prev ;
		return *this;
	}
	Self operator--(int)
	{
		Self tmp(_node);
		_node=_node->_prev ;
		return tmp;
	}
	Node* _node;
};


//双向循环列表
template<class T>
class List
{
public:
	typedef _ListNode<T> Node;
	typedef _ListIterator<T,T&,T*> Iterator;
	Node* BuyNode(const T& x)
	{
		Node* node=new Node(x);
		return node;
	}
	List()
	{
		_head=BuyNode(T());     //创建一个头节点
		_head->_next =_head;
		_head->_prev =_head;
	}
	void PushBack(const T& x)
	{    //这个是用普通方法实现的
		/*Node* tail=_head->_prev ;
		Node* tmp=BuyNode(x);

		tail->_next =tmp;
		tmp->_prev =tail;

		tmp->_next =_head;
		_head->_prev =tmp;*/
	        //这个是用迭代器实现的
		Insert(End(),x);
	}
	void PopBack()
	{
		Erase(--End());
	}
	void PushFront(const T& x)
	{
		Insert(Begin(),x);
	}
	void PopFront()
	{
		Erase(Begin());
	}
	void Insert(Iterator pos,const T& x) //在pos之前插入
	{
		Node* tmp=BuyNode(x);
		Node* cur=pos._node ->_prev ;

		cur->_next =tmp;
		tmp->_prev =cur;

		tmp->_next =pos._node ;
		pos._node ->_prev =tmp;
	}
	void Erase(Iterator pos)
	{
		assert(pos!=End());
		Node* node=pos._node ;
		if(pos._node ->_next ==_head)
		{
			++pos;
		}
	    ++pos;
		Node* prev=node->_prev ;
		Node* next=node->_next ;
		prev->_next =next;
		next->_prev =prev;
		delete node ;
	}
	Iterator Begin()   //[
	{
		return Iterator(_head->_next );
	}
	Iterator End()    //)
	{
		return Iterator(_head);
	}
private:
	Node* _head;
};

int main()
{
	/*list<int> l;
	l.push_back (1);
	l.push_back (2);
	l.push_back (3);
	l.push_back (4);
	list<int>::iterator it=l.begin ();
	while(it!=l.end())
	{
		cout<<*it<<" ";
		++it;
	}*/
	//i调用了匿名对象
	//int i=int();   //i=0
	//int i=int(2);   //i=2
	//int j=9;
	//cout<<i<<endl;
	//cout<<j<<endl;

	List<int> l;
	l.PushBack (1);
	l.PushBack (2);
	l.PushBack (3);
	l.PushBack (4);
	/*l.PushFront (1);
	l.PushFront (2);
	l.PushFront (3);
	l.PushFront (4);*/
	l.PopFront ();
	//l.PopBack ();
	List<int>::Iterator it=l.Begin();
	while(it!=l.End())
	{
		cout<<*it<<" ";
		++it;
	}
	cout<<endl;
	system("pause");
	return 0;
}</span>