迭代器与List

     List是一个容器，在STL库中（标准模板库）。实质上就是一个双向链表，而且这个双向链表是有头的；他有一个空的头结点，插入删除时不用判断表中有无数据，双向循环可以轻易的_head->prev轻松地找到最后一个节点end。

     它使用内置的迭代器来遍历和管理这个容器，迭代器就像指针一样管理着这个空间，重载实现了与指针以一样的++、*、= 、!=等操作符。 下面让我们简单的模拟实现以下吧。

struct ListNode     //双向链表结点
{
	ListNode(const T& data = 0)
	:_next(NULL), _prev(NULL), _data(data)
	{}
	T _data;
	ListNode<T>* _next;
	ListNode<T>* _prev;
};

template<class T>
class List
{
	typedef ListNode<T> Node;
public:
	typedef  _Iterator<T, T&, T*>  Iterator;
	typedef _Iterator<T, const T&, const T*> ConstIterator;
	typedef _ReverseIterator<T, T&, T*> ReverseIterator;
	typedef _ReverseIterator<T, const T&,const T*> ConstReverseIterator;
	List()
		:_head(NewNode())
	{
		_head->_next = _head;
		_head->_prev = _head;
	}
	~List()
	{
		release();
		delete _head;
	}
	Node* NewNode(const T& x)
	{
		return new Node(x);
	}
	Node* NewNode()
	{
		return new Node();
	}

	void PushBack(const T& x)   //尾插
	{
		Node* tail = _head->_prev;
		Node* tmp = NewNode(x);
		tail->_next = tmp;
		tmp->_prev = tail;
		tmp->_next = _head;
		_head->_prev = tmp;
	}


	Iterator Begin()  	//定义返回迭代器类型的Begin()和End()  
	{
		return Iterator(_head->_next);
	}
	Iterator End()
	{
		return Iterator(_head);
	}

	ConstIterator Begin()const	 
	{
		return ConstIterator(_head->_next);
	}
	ConstIterator End()const
	{
		return ConstIterator(_head);
	}
	ReverseIterator rBegin()     //定义返回迭代器类型的rBegin()和rEnd()
	{
		return ReverseIterator(_head->_prev);
	}
	ReverseIterator rEnd()
	{
		return ReverseIterator(_head);
	}
	ConstReverseIterator rBegin()const
	{
		return ConstReverseIterator(_head->_prev);
	}
	ConstReverseIterator rEnd()const
	{
		return ConstReverseIterator(_head);
	}
	void release()
	{
		Node* tmp = _head->_next;
		while (tmp != _head)
		{
			Node* del = tmp;
			tmp = tmp->_next;
			delete del;
		}
	}

	Iterator Erase(Iterator it)
	{
		Node* prev = it._node->_prev;
		Node* next = it._node->_next;
		delete it._node;
		prev->_next = next;
		next->_prev = prev;
		return  prev;
	}
	void PopBack()
	{
		Erase(_head->_prev);
	}
	void remove(int pos)
	{
		Iterator it = Begin();
		while (it != End())
		{
			if (pos == 1)
			it = Erase(it);
			++it;
			--pos;
		}
	}
protected:
	Node* _head;
};

    List实现了尾删和尾插还有随机位置的删除

#include 
    
    
     
     
using namespace std;
template
     
     
      
      
struct ListNode
{
	ListNode(const T& data = 0)
	:_next(NULL), _prev(NULL), _data(data)
	{}
	T _data;
	ListNode
      
      
       
       * _next;
	ListNode
       
       
        
        * _prev;
};

template
        
        
          struct _Iterator { typedef ListNode 
         
           Node; typedef _Iterator 
          
            Self; _Iterator(Node* node) :_node(node) {} Ref operator*() { return _node->_data; } Self& operator++() { _node = _node->_next; return *this; } bool operator!=(const Self& other)const { return other._node != _node; } Node* _node; }; template 
           
             struct _ReverseIterator { typedef ListNode 
            
              Node; typedef _Iterator 
             
               Self; _ReverseIterator(Node* node) :_node(node) {} Ref operator*() { return _node->_data; } Self& operator++() { _node = _node->_prev; return *this; } bool operator!=(const Self& other)const { return other._node != _node; } Node* _node; }; template 
              
                class List { typedef ListNode 
               
                 Node; public: typedef _Iterator 
                
                  Iterator; typedef _Iterator 
                 
                   ConstIterator; typedef _ReverseIterator 
                  
                    ReverseIterator; typedef _ReverseIterator 
                   
                     ConstReverseIterator; List() :_head(NewNode()) { _head->_next = _head; _head->_prev = _head; } ~List() { release(); delete _head; } Node* NewNode(const T& x) { return new Node(x); } Node* NewNode() { return new Node(); } void PushBack(const T& x) //尾插 { Node* tail = _head->_prev; Node* tmp = NewNode(x); tail->_next = tmp; tmp->_prev = tail; tmp->_next = _head; _head->_prev = tmp; } Iterator Begin() //定义返回迭代器类型的Begin()和End() { return Iterator(_head->_next); } Iterator End() { return Iterator(_head); } ConstIterator Begin()const { return ConstIterator(_head->_next); } ConstIterator End()const { return ConstIterator(_head); } ReverseIterator rBegin() //定义返回迭代器类型的rBegin()和rEnd() { return ReverseIterator(_head->_prev); } ReverseIterator rEnd() { return ReverseIterator(_head); } ConstReverseIterator rBegin()const { return ConstReverseIterator(_head->_prev); } ConstReverseIterator rEnd()const { return ConstReverseIterator(_head); } void release() { Node* tmp = _head->_next; while (tmp != _head) { Node* del = tmp; tmp = tmp->_next; delete del; } } Iterator Erase(Iterator it) { Node* prev = it._node->_prev; Node* next = it._node->_next; delete it._node; prev->_next = next; next->_prev = prev; return prev; } void PopBack() { Erase(_head->_prev); } void remove(int pos) { Iterator it = Begin(); while (it != End()) { if (pos == 1) it = Erase(it); ++it; --pos; } } protected: Node* _head; };