用迭代器实现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>