初识STL——迭代器List

迭代器

STL有6大组件

迭代器（iterator）是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。迭代器修改了常规指针的接口，所谓迭代器是一种概念上的抽象：那些行为上像迭代器的东西都可以叫做迭代器。
迭代器提供一些基本操作符：*、++、==、!=、=。这些操作和C/C++“操作array元素”时的指针接口一致。

---

• list::iterator 的模拟实现

源代码

#pragma once

#include <iostream>
using namespace std;
#include <assert.h>

template<class T>
struct ListNode
{
    ListNode* _prev;
    ListNode* _next;
    T _data;
    ListNode(const T& x)
        :_data(NULL)
        , _prev(NULL)
        , _next(NULL)
    {}  
};

template<class T,class Ref,class Ptr>
struct ListIterator
{
    typedef ListNode<T> Node;
    typedef ListIterator<T, Ref, Ptr> Self;

    Node* _node;

    ListIterator(Node * node)
        :_node(node)
    {}
    bool operator==(const Self& x)
    {
        return _node == x._node;
    }
    bool operator!=(const Self& x)
    {
        return _node != x._node;
    }
    Ref operator*()
    {
        return _node->_data;
    }

    Ptr operator->()
    {
        return &(operatpr*());
    }

    Self& operator++() //前置++
    {
        _node = _node->_next;
        return *this;
    }
    Self operator++(int) //后置++
    {
        Self tmp(*this);
        _node = _node->_next;
        return tmp;
    }
    Self operator--(int)//后置--
    {
        Self tmp(*this);
        _node = _node->_prev;
        return tmp;
    }
    Self& operator--()//前置--
    {
        _node = _node->_prev;
        return *this;
    }
};

template<class T>
class List
{
public:
    typedef ListNode<T> Node;
    typedef ListIterator<T, T&, T*> Iterator;
    typedef ListIterator<const T,const T&,const T*> ConstIterator;
public:

    List()
        :_head(BuyNode(T()))
    {
        _head = _head->_next;
        _head = _head->_prev;
    }

    ~List()
    {
        Clear();
        delete _head;
        _head = NULL;
    }
    void Clear()
    {
        Node* cur = _head;
        while (cur != _head)
        {
            Node* next = cur->_next;
            delete cur;
            cur = next;
        }
        _head = _head->_next;
        _head = _head->_prev;
    }
    Iterator Begin()
    {
        return _head->_next;
    }
    ConstIterator Begin() const
    {
        return _head->_next;
    }
    Iterator End()
    {
        return _head;
    }
    ConstIterator End() const
    {
        return _head;
    }
    void PushBcak(const T& x)
    {
        Node* cur = BuyNode(x);
        Node* tail = _head->_prev;

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

    void PushFront(const T& x)
    {
    /*  Node* cur = BuyNode(x);
        Node* next = _head->_next;
        if ()
        cur->_prev = _head;
        next->_next = cur;*/
    }

    Iterator Find(const T& x)
    {
        Node* cur = Begin();
        while (cur != _head)
        {
            if (*cur == x)
            {
                return cur;
            }
            ++cur;
        }
        return _head;
    }
    Iterator Erase(Iterator pos)
    {
        assert(pos._node&&pos._node != _head);
        Node* Next = pos._node->_next;
        Node* Prev = pos._node->_prev;

        Next->_prev = Prev;
        Prev->_next = Next;
        delete pos._node;
        return Next;
    }

    Iterator Insert(Iterator pos, const T& x)
    {
        assert(pos._node);
        Node* Next = pos._node;
        Node* Prev = Next->_prev;

        Node* Tmp = new Node(x);

        Next->_prev = Tmp;
        Tmp->_next = Next;
        Prev->_next = Tmp;
        Tmp->_prev = Prev;

        return Tmp;
    }
    void Print()
    {
        Node* cur = _head;
        while (cur->_next != _head)
        {
            cur = cur->_next;
            cout << cur->_data << "  ";
        }
        cout << endl;
    }
protected:
    Node* BuyNode(const T& x)
    {
        return new Node(x);
    }
protected:
    Node* _head;
};


void TestList()
{
    List<int> l1;
    l1.PushBcak(1);
    l1.Print();
}