STL与数据结构：迭代器Iterator

迭代器

迭代器可以遍历集合的对象。为各种容器提供公共的操作接口，隔离对容器的遍历操作和底层实现，从而解耦。
例如：使一个算法如find()，对Vector，list，dequeue均适用。

迭代器代码示例：

#ifndef LINKED
#define LINKED

template<class T>
class Linked {

    protected:
        struct Node
        {
            T item;
			Node* next; 
        };
        Node* head;
        long length;

    public:
        class Iterator {//类内的类，即内部类
        
            friend class Linked<T>;//此处使用友元类，使Iterator类可以使用linked前面部分的Nod结构和head，length。
            
            protected:
                Node* nodePtr;
                
                Iterator (Node* newPtr)
                {
                    nodePtr = newPtr;
                } // constructor构造函数


             public:
、
                Iterator()
                {
                	
                } // default constructor默认构造函数

                bool operator== (const Iterator& itr) const
                {
                    return nodePtr == itr.nodePtr;
                } // overloading == 重载==


                bool operator!= (const Iterator& itr) const
                {
                    return nodePtr != itr.nodePtr;
                } // overloading !=

                T& operator*() const
                {
                    return nodePtr -> item;
                } // overloading *

                Iterator operator++(int)
                {
                    Iterator temp = *this;
                    nodePtr = nodePtr -> next;
                    return temp;
                } // post-increment ++

                Iterator& operator++()
                {
                    nodePtr=nodePtr->next;
					return *this; 
                } // pre-increment ++

        Linked()
        {
            head = NULL;
            length = 0;
        } // default constructor 链表的构造函数


        long size()
        {
            return length;
        } // size


        void push_front (const T &newItem)
        {
            Node* newHead = new Node;
            newHead -> item = newItem;
            newHead -> next = head;
            head = newHead;
            length++;
        } // push_front


        void pop_front()
        {
            Node* oldHead = head;
            head = head -> next;
            delete oldHead;
            length--;
        } // method popFront


        Linked<T>& operator= (const Linked<T>& otherLinked)        
        {
            Linked<T> tempLinked;

            Node* tempPtr;

            // Destroy the calling object:
            while (head != NULL)
                pop_front();


            for (tempPtr = otherLinked.head; tempPtr != NULL;
                                             tempPtr = tempPtr -> next)
                tempLinked.push_front (tempPtr -> item);


            for (tempPtr = tempLinked.head; tempPtr != NULL; 
                                            tempPtr = tempPtr -> next)
                push_front (tempPtr -> item);

            return *this;
        } // overloading =


        Iterator begin()
        {
             ///----(4)-----///
            return Iterator(head);
        } // begin


        Iterator end()
        {
            return Iterator (NULL);
        } // end


        ~Linked()
        {
            while (head != NULL)
            pop_front();
        } // destructor
}; // class Linked

#endif

#include <iostream>
#include "linked-todo.h"
using namespace std;

int main() 
{
	Linked<int> linkobj;
	Linked<int> reverse;
	for (int i = 100; i>=1 ; i--)
    {
		linkobj.push_front(i);
	}
	Linked<int>::Iterator first = linkobj.begin();
	Linked<int>::Iterator last = linkobj.end();
	
    for(first;first!=last;first++)
    {
    	reverse.push_front(*first);
	}
	
   	first = reverse.begin();
	last = reverse.end();
    
	for(first;first!=last;first++)
    {
    	cout<<*first<<endl;
	}
	return 0;
}

根据上述代码，Iterator和容器的关系如下图所示，Iterator为容器（不一定是List）的内部类。

刚才看到一篇很清晰的文章，可参考链接: C++迭代器
这一篇文章总结很清晰，推荐：C++迭代器（iterator）

祝愿大家都有所收获。