模拟实现list(迭代器)

list同vector类似，都是库提供的众多容器中的一个。同时list 以模板方式实现，可以处理任意型别的变量，包括使用者自定义的资料型态。
在编程语言中List 是标准类库中的一个类，可以简单视之为双向链表，以线性列的方式管理物件集合。和vector不一样的是，list不支持对元素的任意存取。list中提供的成员函数与vector类似，不过list提供对表首元素的操作push_front、pop_front，这是vector不具备的。和vector另一点不同的是，list的迭代器不会存在失效的情况，他不像vector会保留备份空间，在超过容量额度时重新全部分配内存，导致迭代器失效；list没有备份空间的概念，出入一个元素就申请一个元素的空间，所以它的迭代器不会失效。
在这里以双向带头链表实现：

using namespace std;#include <iostream>#include <assert.h>//双向有头链表template <class T>class ListNode{public:    ListNode()        :_data(NULL)    {}    ListNode(const T&x)        :_data(x)        ,_next(NULL)        ,_prev(NULL)    {}public:    T _data;    ListNode<T> * _next;    ListNode<T> * _prev;};template <class T, class Ref, class Ptr>class ListIterator{public:    typedef ListNode<T> Node;    typedef ListIterator<T, Ref, Ptr> Self;    ListIterator()        :_node(0)    {}    ListIterator(Node *node)        :_node(node)    {}    Ref operator *() {        return _node->_data;    }    Ptr operator->(){        return &(_node->_data);    }    Self &operator++() {        _node = _node->_next;        return *this;    }    Self operator++(int)    {        Self temp = _node;        _node = _node->_next;        return Self(temp);    }    Self &operator--() {        _node = _node->_prev;        return *this;    }    Self operator--(int) {        Self temp = _node;        _node = _node->_prev;        return Self(temp);    }    bool operator!=(const Self& s) const    {        return this->_node != s._node;    }    bool operator==(const Self& s) const    {        return this->_node == s._node;    }public:    Node *_node;};template <class T>class List{public:    typedef ListIterator<T, T&, T*> Iterator;    typedef ListNode<T> Node;public:    List()   //构造        :_head(new ListNode<T>)    {        _head->_next = _head;        _head->_prev = _head;    }    List(const List&l)   //拷贝构造        :_head(new ListNode<T>)    {        _head->_next = _head;        _head->_prev = _head;        Node *front = l._head->_next;        Node* tail = l._head->_prev;        while (front != tail) {            PushBack(front->_data);            front = front->_next;        }    }    List &operator = (const List &l) {  //赋值运算符重载        List<T> *nHead = new ListNode<T>;        Node *front = l._head->_next;        Node* tail = l._head->_prev;        while (front != tail)        {            nHead->PushBack(front->_data);        }        Clear();            List<T> nHead;        _head = nHead;    }    List(const T *Array, size_t size)    //        :_head(new ListNode<T>)    {        _head->_next = _head;        _head->_prev = _head;        for (size_t i = 0; i < size; i++) {            PushBack(Array[i]);        }    }    ~List()    {        if (_head) {            delete _head;        }    }public:    void PushBack(const T &t)  //尾插     {        Node *tail = _head->_prev;        Node *temp = new Node(t);        tail->_next = temp;        temp->_prev = tail;        _head->_prev = temp;        temp->_next = _head;    }    void PopBack() {   //尾删        assert(_head != _head->_next);  //空链        Node *tail = _head->_prev;        //        _head->_prev = tail->_prev;        tail->_prev->_next = _head;        delete tail;    }    void PushFront(const T&t){   //头插        Node *cur = new Node(T);        cur->_next = _head->_next;        cur->_prev = _head;        _head->_next->_prev = cur;        _head->_next = cur;    }    void PopFront() {   //头删        assert(_head != _head->_next);        Node *del = _head->_next;        _head->_next = del->_next;        del->_next->_prev = _head;        delete del;    }    List& Back()    {        return _head->_prev;    }    size_t Size()    {        int count = 0;        Node *cur = _head;        while (cur != _head->_prev) {            count++;            cur = cur->_next;        }        return count;    }    bool Empty()    {        return _head == _head->_next;    }public:    Iterator Begin()    {        return Iterator(_head->_next);    }    Iterator End()    {        return Iterator(_head->_prev);    }    Iterator Find(const T &t)    {        Node* front = _head->_next;        Node* tail = _head->_prev;        while (front != tail) {            if (front->_data == t)                return Iterator(front);            front=front->_next;        }        return NULL;    }    Iterator Erase(Iterator pos) {   //定点删除        Node *next = pos._node->_next;        pos._node->_prev->_next = next;        next->_prev = pos._node->_prev;        delete pos._node;        return Iterator(next);    }    Iterator Insetr(Iterator pos, const T&x) {    //定点插入        Node *next = pos._node->_next;        Node *cur = pos._node;        Node *temp = new Node(x);        cur->_next = temp;        temp->_prev = cur;        temp->_next = next;        next->_prev = temp;        return Iterator(temp);    }    void Clear()    {        Node *front = _head->_next;        Node *tail = _head->_prev;        Node *del;        while (front != tail) {            del = front;            delete del;            front = front->_next;        }    }    T Top()    {        if(!Empty())        return _head->_next->_data;        return NULL;    }private:    Node *_head;};