C++中迭代器原理、失效和简单实现

目录

1. 迭代器的使用
2. 迭代器的种类
3. 迭代器的失效
4. 迭代器的实现

1.迭代器的使用

为了提高C++编程的效率，STL中提供了许多容器，包括vector、list、map、set等。有些容器例如vector可以通过脚标索引的方式访问容器里面的数据，但是大部分的容器不能使用这种方式，例如list、map、set。STL中每种容器在实现的时候设计了一个内嵌的iterator类，不同的容器有自己专属的迭代器，使用迭代器来访问容器中的数据。除此之外，通过迭代器，可以将容器和通用算法结合在一起，只要给予算法不同的迭代器，就可以对不同容器执行相同的操作，例如find查找函数。迭代器对指针的一些基本操作如*、->、++、==、!=、=进行了重载，使其具有了遍历复杂数据结构的能力，其遍历机制取决于所遍历的数据结构，所有迭代的使用和指针的使用非常相似。通过begin，end函数获取容器的头部和尾部迭代器，end 迭代器不包含在容器之内，当begin和end返回的迭代器相同时表示容器为空。

template<typename InputIterator, typename T>
InputIterator find(InputIterator first, InputIterator last, const T &value)
{
    while (first != last && *frist != value)
        ++first;
    return first;
}

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;

int main(int argc, const char *argv[])
{
    int arr[] = { , , , , };

    vector<int> iVec(arr, arr + );//定义容器vector
    list<int> iList(arr, arr + );//定义容器list

    //在容器iVec的头部和尾部之间寻找整形数3
    vector<int>::iterator iter1 = find(iVec.begin(), iVec.end(), );
    if (iter1 == iVec.end())
        cout<<"3 not found"<<endl;
    else
        cout<<"3 found"<<endl;

    //在容器iList的头部和尾部之间寻找整形数4
    list<int>::iterator iter2 = find(iList.begin(), iList.end(), );
    if (iter2 == iList.end())
        cout<<"4 not found"<<endl;
    else
        cout<<"4 found"<<endl;

    return ;
}

2.迭代器的种类

根据迭代器所支持的操作，可以把迭代器分为5类。

1)   输入迭代器：是只读迭代器，在每个被遍历的位置上只能读取一次。例如上面find函数参数就是输入迭代器。

2)   输出迭代器：是只写迭代器，在每个被遍历的位置上只能被写一次。

3)   前向迭代器：兼具输入和输出迭代器的能力，但是它可以对同一个位置重复进行读和写。但它不支持operator--，所以只能向前移动。

4)   双向迭代器：很像前向迭代器，只是它向后移动和向前移动同样容易。

5)   随机访问迭代器：有双向迭代器的所有功能。而且，它还提供了“迭代器算术”，即在一步内可以向前或向后跳跃任意位置，  包含指针的所有操作，可进行随机访问，随意移动指定的步数。支持前面四种Iterator的所有操作，并另外支持it + n、it - n、it += n、 it -= n、it1 - it2和it[n]等操作。

STL每种容器类型都定义了 const_iterator，只能读取容器的值，不能修改所指向容器范围内元素的值。vector、string、Deque随机存取迭代器；List、Set、map、mutiset、multimap双向迭代器。

3.迭代器失效

容器的插入insert和erase操作可能导致迭代器失效，对于erase操作不要使用操作之前的迭代器，因为erase的那个迭代器一定失效了，正确的做法是返回删除操作时候的那个迭代器。

#include <vector>
using namespace std;

int main(int argc, const char *argv[]) {
    int arr[] = { , , , ,  };

    vector<int> iVec(arr, arr + ); //定义容器vector
    //迭代器失效
//    for (vector<int>::iterator it = iVec.begin(); it != iVec.end();) {
//        iVec.erase(it);
//    }
    //返回erase操作之后的迭代器
    for (vector<int>::iterator it = iVec.begin();it != iVec.end();) {
        it = iVec.erase(it);
    }
    return ;
}

4.迭代器的实现

STL中每个容器都有自己的迭代器，各种迭代器的接口相同，内部实现却不相同，这也直接体现了泛型编程的概念，下面在单链表类中内嵌入一个iterator的类来实现单链表的迭代

 #include <iostream>

 template<typename T>
 struct ListNode {
     T value;
     ListNode* next;
     ListNode() {
         next = ;
     }
     ListNode(T val, ListNode *p = nullptr) :
             value(val), next(p) {
     }
 };

 template<typename T>
 class List {
 private:
     ListNode<T> *m_pHead;
     ListNode<T> *m_pTail;
     int m_nSize;
 public:
     List() {
         m_pHead = nullptr;
         m_pTail = nullptr;
         m_nSize = ;
     }
     //从链表尾部插入元素
     void push_back(T value) {
         if (m_pHead == nullptr) {
             m_pHead = new ListNode<T>(value);
             m_pTail = m_pHead;
         } else {
             m_pTail->next = new ListNode<T>(value);
             m_pTail = m_pTail->next;
         }

     }

     //打印链表元素
     void print(std::ostream &os = std::cout) const {
         for (ListNode<T> *ptr = m_pHead; ptr != m_pTail->next ; ptr = ptr->next)
             std::cout << ptr->value << " ";
         os << std::endl;
     }

     //内置迭代器
     class iterator {
     private:
         ListNode<T> *m_ptr;
     public:
         iterator(ListNode<T>* p = nullptr) :
                 m_ptr(p) {
         }

         T operator*() const {
             return m_ptr->value;
         }
         ListNode<T>* operator->() const {
             return m_ptr;
         }
         iterator& operator++() {
             m_ptr = m_ptr->next;
             return *this;
         }
         iterator operator++(int) {
             ListNode<T>* tmp = m_ptr;
             m_ptr = m_ptr->next;
             return iterator(tmp);
         }

         bool operator==(const iterator &arg) const {
             return arg.m_ptr == this->m_ptr;
         }

         bool operator!=(const iterator &arg) const {
             return arg.m_ptr != this->m_ptr;
         }

     };

     //返回链表头部指针
     iterator begin() const {
         return iterator(m_pHead);
     }

     //返回链表尾部指针
     iterator end() const {
         return iterator(m_pTail->next);
     }

     //其它成员函数

 };

 int main() {
     List<int> l;
     l.push_back();
     l.push_back();
     l.print();
     for (List<int>::iterator it = l.begin(); it != l.end(); ++it) {
         std::cout << *it << " ";
     }
     std::cout << std::endl;
     return ;
 }

参考： http://blog.csdn.net/shudou/article/details/11099931