使用迭代器模拟STL list

STL中的 list是一个有头节点的双向循环链表，掌握了lst的list，vector自然不在话下。
STL中使用迭代器（iterator）指向list的节点，并进行增删查改等操作。下面我们模拟实现STL中list的常用操作。
首先，我们要知道，list本身和list的节点是不同的结构，需要分开设计，以下是模拟STL list的节点结构：

template<class T>
struct MyListNode
{
    MyListNode<T>* _prev;
    MyListNode<T>* _next;

    T _data;

    MyListNode(const T& x)//节点的构造函数
        :_data(x)
        , _next(NULL)
        , _prev(NULL){}
};

显然，list是一个有头节点的双向循环链表，示意图如下：

在设计list迭代器时，注意删除元素导致的迭代器失效：

template<class T, class Ref, class Ptr>
struct ListIterator//迭代器
{
    typedef MyListNode<T> Node;
    Node* _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(*this);
        _node = _node->_next;
        return tmp;
    }

    Self operator--(int)
    {
        Self tmp(*this);
        _node = _node->_prev;
        return _tmp;
    }

    bool operator != (const Self& s)const
    {
        return _node != s._node;
    }
};

下面是list数据结构的模拟实现代码：

template<class T>
class List
{
public:
    typedef MyListNode<T> Node;
    typedef ListIterator<T, T&, T*> Iterator;//const 型迭代器和非const型
    typedef ListIterator<T, const T&, const T*> ConstIterator;

    List()
    {
        _head = BuyNode(T());//用匿名对象初始化
        _head->_next = _head;
        _head->_prev = _head;
    }

    ~List()
    {
        Clear();
        delete _head;
        _head = NULL;
    }

    void Clear()
    {
        Node* cur = _head->_next;
        while (cur != _head)
        {
            Node* next = cur->_next;//防止迭代器失效
            delete cur;
            cur = next;
        }
    }

    Iterator Begin()
    {
        return _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 = BuyNode(x);

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

    void PopBack()//尾删
    {
        Iterator tmp = End();
        Erase(--tmp);
    }

    void PushFront(const T& x)//头插
    {
        Insert(Begin(), x);
    }

    void PopFront()//头删，不能删除头结点
    {
        Erase(Begin());
    }

    Iterator Insert(Iterator pos, const T& x)//任意位置插入
    {
        Node* tmp = BuyNode(x);
        Node* next = pos._node->_next;
        Node* prev = pos._node->_prev;
        prev->_next = tmp;
        tmp->_prev = prev;
        tmp->_next = next;
        next->_prev = tmp;
        return tmp;
    }

    Iterator Erase(Iterator pos)//任意位置删除
    {
        Node* next = pos._node->_next;
        Node* prev = pos._node->_prev;
        prev->_next = next;
        next->_prev = prev;
        delete pos._node;
        return next;
    }


//翻转
    void Reverse()
    {
        Node* cur = _head;
        Node* last = cur->_next;
        Node* tmp = cur;
        Node* NewHead = NULL;
        while (cur)
        {
            tmp = cur;
            cur = cur->_next;
            tmp->_next = NewHead;
            tmp->_prev = cur;
            NewHead = tmp;
        }
        _head = NewHead;
        _head->_prev = last;
        last->_next = _head;
    }

//将一段区间移动到pos之前
    Iterator Transfor(Iterator pos, Iterator first, Iterator last)
    {
        Node* cur = pos._node;
        Node* prev = cur->_prev;
        Node* firstN = first._node;
        Node* lastN = last._node;
        Node* next = lastN->_next;
        prev->_next = firstN;
        firstN->_prev = prev;
        lastN->_next = cur;
        cur->_prev = lastN;
        cur->_next = next;
        next->_prev = cur;
        return next;
    }

//去重（只能去除连续相同的）
    void Unique()
    {
        Iterator first = Begin();
        Iterator last = End();
        if (first == last)
            return;
        Iterator next = first;
        while (next != last)
        {
            if (*first == *next)
            {
                next = Erase(next);//防止迭代器失效
            }
            else
            {
                first = next;
                next = first;
                ++next;
            }
        }
    }

//删除所有值为data的元素
    void Remove(const T& data)
    {
        Iterator first = Begin();
        Iterator last = End();
        Iterator next = first;
        while (first != last)
        {
            ++next;
            if (*first == data)
            {
                Erase(first);
            }
            first = next;
        }
    }

//查找
    Iterator Find(List<int>& l1, const T& data)
    {
        List<int>::Iterator it1 = l1.Begin();
        while (it1 != l1.End())
        {
            if (it1._node->_data == data)
            {
                return it1;
            }
            else
            {
                ++it1;
            }
        }
        return NULL;
    }
protected:
    Node* BuyNode(const T& x)
    {
        return new Node(x);
    }
private:
    Node* _head;
};

void PrintMylst(const List<int>& l1)
{
    List<int>::ConstIterator it1 = l1.Begin();
    while (it1 != l1.End())
    {
        cout << *it1 << " ";
        ++it1;
    }
    cout << endl;
}

测试用例：

void Test()
{
    List<int> l1;
    l1.PushBack(1);
    l1.PushBack(2);
    l1.PushBack(3);
    l1.PushBack(4);
    l1.PushFront(5);
    /*l1.PopFront();
    l1.PopFront();*/
    PrintMylst(l1);
}

int main()
{
    Test();
    system("pause\n");
    return 0;
}

结果如下：