list 迭代器的简单实现

List是一个容器，在STL库中（标准模板库）。实质上就是一个双向链表，而且这个双向链表是有头的；他有一个空的头结点，插入删除时不用判断表中有无数据，双向循环可以轻易的_head->prev轻松地找到最后一个节点end。
它使用内置的迭代器来遍历和管理这个容器，迭代器就像指针一样管理着这个空间，重载实现了与指针一样的++、*、= 、!=等操作符。迭代器实质上就是遍历访问容器里面的元素。不同的容器，它的遍历方式不同，迭代器也就各不相同。

#include <iostream>
using namespace std;
template<class T>
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 Ref, class Ptr>
struct _Iterator//----------迭代器的重载
{
    typedef ListNode<T> Node;
    typedef _Iterator<T, Ref, Ptr> 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<class T, class Ref, class Ptr>
struct _ReverseIterator   //-----------反向迭代器重载
{

    typedef ListNode<T> Node;
    typedef _Iterator<T, Ref, Ptr> 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 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()// 用于head传值
    {
        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;
};