C++的迭代器iterator的使用方法

“過一個平凡無趣的人生實在太容易了，你可以不讀書，不冒險，不運動，不寫作，不外出，不折騰……但是，人生最后悔的事情就是：我本可以。”——xxx

要訪問順序容器和關聯容器中的元素，需要通過“迭代器（iterator）”進行。迭代器是一個變量，相當於容器和操縱容器的算法之間的中介。迭代器可以指向容器中的某個元素，通過迭代器就可以讀寫它指向的元素。從這一點上看，迭代器和指針類似。

迭代器是一種檢查容器內元素並遍歷元素的數據類型。C++更趨向於使用迭代器而不是下標操作，因為標准庫為每一種標准容器（如vector）定義了一種迭代器類型，而只用少數容器（如vector）支持下標操作訪問容器元素。
除此之外，STL中迭代器一個最重要的作用就是作為容器(vector,list等)與STL算法的粘結劑，只要容器提供迭代器的接口，同一套算法代碼可以利用在完全不同的容器中，這是抽象思想的經典應用。
迭代器按照定義方式分成以下四種。

1) 正向迭代器，定義方法如下：

容器類名::iterator  迭代器名;

2) 常量正向迭代器，定義方法如下：

容器類名::const_iterator  迭代器名;

3) 反向迭代器，定義方法如下：

容器類名::reverse_iterator  迭代器名;

4) 常量反向迭代器，定義方法如下：

容器類名::const_reverse_iterator  迭代器名;

定義和初始化

　　每種容器都定義了自己的迭代器類型，如vector:

vector<int>::iterator    iter;    //定義一個名為iter的變量

　　每種容器都定義了一對名為begin和en的函數，用於返回迭代器。下面對迭代器進行初始化操作：

vector<int>    ivec;
vector<int>::iterator    iter1=ivec.bengin();    //將迭代器iter1初始化為指向ivec容器的第一個元素

vector<int>::iterator   iter2=ivec.end();    //將迭代器iter2初始化為指向ivec容器的最后一個元素的下一個位置

　　注意end並不指向容器的任何元素，而是指向容器的最后元素的下一位置，稱為超出末端迭代器。如果vector為空，則begin返回的迭代器和end返回的迭代器相同。一旦向上面這樣定義和初始化，就相當於把該迭代器和容器進行了某種關聯，就像把一個指針初始化為指向某一空間地址一樣。

 

常用操作

　　下面列出了迭代器的常用運算操作：

*iter                //對iter進行解引用，返回迭代器iter指向的元素的引用
iter->men            //對iter進行解引用，獲取指定元素中名為men的成員。等效於(*iter).men
++iter                //給iter加1，使其指向容器的下一個元素
iter++
--iter                //給iter減1，使其指向容器的前一個元素
iter--
iter1==iter2        //比較兩個迭代器是否相等，當它們指向同一個容器的同一個元素或者都指向同同一個容器的超出末端的下一個位置時，它們相等 
iter1!=iter2        

　　假設已經聲明一個vector<int>的ivec容器，下面用迭代器來遍歷ivec容器，把其每個元素重置為0：

for(vector<int>::iterator iter=ivec.begin();iter!=ivec.end();++iter)
        *iter=0;

　　在C++定義的容器類型中，只有vector和queue容器提供迭代器算數運算和除!=和==之外的關系運算：

iter+n     //在迭代器上加（減）整數n，將產生指向容器中錢前面（后面）第n個元素的迭代器。新計算出來的迭代器必須指向容器中的元素或超出容器末端的下一個元素
iter-n

iter1+=iter2        //將iter1加上或減去iter2的運算結果賦給iter1。兩個迭代器必須指向容器中的元素或超出容器末端的下一個元素
iter1-=iter2

iter1-iter2            //兩個迭代器的減法，得出兩個迭代器的距離。兩個迭代器必須指向容器中的元素或超出容器末端的下一個元素

>,>=,<,<=        //元素靠后的迭代器大於靠前的迭代器。兩個迭代器必須指向容器中的元素或超出容器末端的下一個元素

　　注意兩個迭代器相減得出兩個迭代器對象的距離，該距離名為difference_type的signed類型的值，該類型類似於size_type類型，也是有vector定義的。可以迭代器算術操作來移動迭代器直接指向某個元素：

vector<int>::iterator    mid=v.begin()+v.size()/2;    //初始化mid迭代器，使其指向v中最靠近正中間的元素

三.迭代器const_iterator

　　每種容器還定義了一種名為const_iterator的類型。該類型的迭代器只能讀取容器中的元素，不能用於改變其值。之前的例子中，普通的迭代器可以對容器中的元素進行解引用並修改，而const_iterator類型的迭代器只能用於讀不能進行重寫。例如可以進行如下操作：

for(vector<int>::const_iterator iter=ivec.begin();iter!=ivec.end();++iter)
     cout<<*iter<<endl;       //合法，讀取容器中元素值

for(vector<int>::const_iterator iter=ivec.begin();iter!=ivec.end();++iter)
    *iter=0;        //不合法，不能進行寫操作

　　const_iterator和const  iterator是不一樣的，后者對迭代器進行聲明時，必須對迭代器進行初始化，並且一旦初始化后就不能修改其值。這有點像常量指針和指針常量的關系。例如：

vector<int>    ivec(10);
const    vector<int>::iterator    iter=ivec.begin();
*iter=0;    //合法，可以改變其指向的元素的值
++iter;    //不合法，無法改變其指向的位置

四.使迭代器失效的操作

　　由於一些對容器的操作如刪除元素或移動元素等會修改容器的內在狀態，這會使得原本指向被移動元素的迭代器失效，也可能同時使其他迭代器失效。使用無效的迭代器是沒有定義的，可能會導致和使用懸垂指針相同的問題。所以在使用迭代器編寫程序時，需要特別留意哪些操作會使迭代器失效。使用無效迭代器會導致嚴重的運行時錯誤。

1. 迭代器(iterator)是一中檢查容器內元素並遍歷元素的數據類型。
(1) 每種容器類型都定義了自己的迭代器類型，如vector:
vector<int>::iterator iter;這條語句定義了一個名為iter的變量，它的數據類型是由vector<int>定義的iterator類型。
(2) 使用迭代器讀取vector中的每一個元素：
vector<int> ivec(10,1);
for(vector<int>::iterator iter=ivec.begin();iter!=ivec.end();++iter)
{
*iter=2; //使用 * 訪問迭代器所指向的元素
}
const_iterator:
只能讀取容器中的元素，而不能修改。
for(vector<int>::const_iterator citer=ivec.begin();citer!=ivec.end();citer++)
{
cout<<*citer;
//*citer=3; error
}
vector<int>::const_iterator 和 const vector<int>::iterator的區別
const vector<int>::iterator newiter=ivec.begin();
*newiter=11; //可以修改指向容器的元素
//newiter++; //迭代器本身不能被修改
(3) iterator的算術操作：
iterator除了進行++,--操作，可以將iter+n,iter-n賦給一個新的iteraor對象。還可以使用一個iterator減去另外一個iterator.
const vector<int>::iterator newiter=ivec.begin();
vector<int>::iterator newiter2=ivec.end();
cout<<"\n"<<newiter2-newiter;

 

使用：

1.  
   vector<int>::iterator it;
2.  
   vector<int> a;
3.  
   vector<int> b;
4.  
   for (it=a.begin(); it<a.end(); it++){
5.  
   cout<<*it<<" ";
6.  
   }
7.  
   for ( it=b.begin(); it<b.end(); it++){
8.  
   cout<<*it<<" ";
9.  
   }

容器一般含有其各自的迭代器型別（iterator types），所以當你使用一般的容器迭代器時，並不需要含入專門的頭文件。

以下是關於代碼的解釋：

vector<int>::iterator it;   

兩個冒號表示作用域操作符。::操作符在其左操作數的作用域內找到其右操作數的名字。

這樣就定義了一個迭代器名字為it（名字可以隨便取），並且這個迭代器的作用域是vector。

這個迭代器it只是初始化，並未賦值，所以在下面的兩個vector a,b都可以用it來遍歷，

就像定義了一個循環變量i，可以遍歷兩個數組a,b道理是一樣的。

vector的.begin()和.end()

vector的.begin()和.end()方法都會返回一個vector::iterator對象，分別指向vector的首元素位置和尾元素的下一個位置（我們可以稱之為結束標志位）。 

*it   迭代器所指向的內容

對一個迭代器的使用與一個指針變量的使用極為相似，或者可以這樣說，指針就是一個非常標准的迭代器。

迭代器的相應型別

我們都知道type_traits 可以萃取出類型的型別，根據不同型別可以執行不同的處理流程。那么對於迭代器來說，是否有針對不同特性迭代器的優化方法呢？答案是肯定的。拿一個STL算法庫中的distance函數來說，distance函數接受兩個迭代器參數，然后計算他們兩者之間的距離。顯然對於不同的迭代器計算效率差別很大。比如對於vector容器來說，由於內存是連續分配的，因此指針直接相減即可獲得兩者的距離；而list容器是鏈式表，內存一般都不是連續分配，因此只能通過一級一級調用next()或其他函數，每調用一次再判斷迭代器是否相等來計算距離。vector迭代器計算distance的效率為O(1),而list則為O(n),n為距離的大小。

因此，根據迭代器不同的特性，將迭代器分為5類:

• Input Iterator:這種迭代器所指的對象為只讀的。
• Ouput Iterator: 所指對象只能進行一次寫入操作。
• Forward Iterator: 允許”讀寫型”算法在迭代器區間內進行讀寫操作，比如說replace函數需要讀取區間內容，根據所讀內容決定是否寫入
• Bidirectional Iterator : 可雙向移動。某些算法需要反向遍歷某個迭代器區間
• Random Access Iterator : 前四種迭代器只提供部分指針算數能力(前三種支持++運算符，后一種還支持–運算符),第五種則支持所有指針的算術運算，包括p + n,p - n,p[n],p1 - p2,p1 < p2

這五種迭代器的繼承關系如下所示。

了解了迭代器的類型，我們就能解釋vector的迭代器和list迭代器的區別了。顯然vector的迭代器具有所有指針算術運算能力，而list由於是雙向鏈表，因此只有雙向讀寫但不能隨機訪問元素。故vector的迭代器種類為Random Access Iterator,list 的迭代器種類為Bidirectional Iterator。

迭代器用法示例

通過迭代器可以讀取它指向的元素，*迭代器名就表示迭代器指向的元素。通過非常量迭代器還能修改其指向的元素。

迭代器都可以進行++操作。反向迭代器和正向迭代器的區別在於：

• 對正向迭代器進行++操作時，迭代器會指向容器中的后一個元素；
• 而對反向迭代器進行++操作時，迭代器會指向容器中的前一個元素。

下面的程序演示了如何通過迭代器遍歷一個 vector 容器中的所有元素。

1. #include <iostream>
2. #include <vector>
3. using namespace std;
4. int main()
5. {
6. vector<int> v; //v是存放int類型變量的可變長數組，開始時沒有元素
7. for (int n = 0; n<5; ++n)
8. v.push_back(n); //push_back成員函數在vector容器尾部添加一個元素
9. vector<int>::iterator i; //定義正向迭代器
10. for (i = v.begin(); i != v.end(); ++i) { //用迭代器遍歷容器
11. cout << *i << " "; //*i 就是迭代器i指向的元素
12. *i *= 2; //每個元素變為原來的2倍
13. }
14. cout << endl;
15. //用反向迭代器遍歷容器
16. for (vector<int>::reverse_iterator j = v.rbegin(); j != v.rend(); ++j)
17. cout << *j << " ";
18. return 0;
19. }

程序的輸出結果是：
0 1 2 3 4
8 6 4 2 0

第 6 行，vector 容器有多個構造函數，如果用無參構造函數初始化，則容器一開始是空的。

第 10 行，begin 成員函數返回指向容器中第一個元素的迭代器。++i 使得 i 指向容器中的下一個元素。end 成員函數返回的不是指向最后一個元素的迭代器，而是指向最后一個元素后面的位置的迭代器，因此循環的終止條件是i != v.end()。

第 16 行定義了反向迭代器用以遍歷容器。反向迭代器進行++操作后，會指向容器中的上一個元素。rbegin 成員函數返回指向容器中最后一個元素的迭代器，rend 成員函數返回指向容器中第一個元素前面的位置的迭代器，因此本循環實際上是從后往前遍歷整個數組。

如果迭代器指向了容器中最后一個元素的后面或第一個元素的前面，再通過該迭代器訪問元素，就有可能導致程序崩潰，這和訪問 NULL 或未初始化的指針指向的地方類似。

第 10 行和第 16 行，寫++i、++j相比於寫i++、j++，程序的執行速度更快。回顧++被重載成前置和后置運算符的例子如下：

1. CDemo CDemo::operator++ ()
2. { //前置++
3. ++n;
4. return *this;
5. }
6. CDemo CDemo::operator ++(int k)
7. { //后置++
8. CDemo tmp(*this); //記錄修改前的對象
9. n++;
10. return tmp; //返回修改前的對象
11. }

后置++要多生成一個局部對象 tmp，因此執行速度比前置的慢。同理，迭代器是一個對象，STL 在重載迭代器的++運算符時，后置形式也比前置形式慢。在次數很多的循環中，++i和i++可能就會造成運行時間上可觀的差別了。因此，本教程在前面特別提到，對循環控制變量i，要養成寫++i、不寫i++的習慣。

注意，容器適配器 stack、queue 和 priority_queue 沒有迭代器。容器適配器有一些成員函數，可以用來對元素進行訪問。

迭代器的功能分類

不同容器的迭代器，其功能強弱有所不同。容器的迭代器的功能強弱，決定了該容器是否支持 STL 中的某種算法。例如，排序算法需要通過隨機訪問迭代器來訪問容器中的元素，因此有的容器就不支持排序算法。

常用的迭代器按功能強弱分為輸入、輸出、正向、雙向、隨機訪問五種，這里只介紹常用的三種。

1) 正向迭代器。假設 p 是一個正向迭代器，則 p 支持以下操作：++p，p++，*p。此外，兩個正向迭代器可以互相賦值，還可以用==和!=運算符進行比較。

2) 雙向迭代器。雙向迭代器具有正向迭代器的全部功能。除此之外，若 p 是一個雙向迭代器，則--p和p--都是有定義的。--p使得 p 朝和++p相反的方向移動。

3) 隨機訪問迭代器。隨機訪問迭代器具有雙向迭代器的全部功能。若 p 是一個隨機訪問迭代器，i 是一個整型變量或常量，則 p 還支持以下操作：

• p+=i：使得 p 往后移動 i 個元素。
• p-=i：使得 p 往前移動 i 個元素。
• p+i：返回 p 后面第 i 個元素的迭代器。
• p-i：返回 p 前面第 i 個元素的迭代器。
• p[i]：返回 p 后面第 i 個元素的引用。

此外，兩個隨機訪問迭代器 p1、p2 還可以用 <、>、<=、>= 運算符進行比較。p1<p2的含義是：p1 經過若干次（至少一次）++操作后，就會等於 p2。其他比較方式的含義與此類似。

對於兩個隨機訪問迭代器 p1、p2，表達式p2-p1也是有定義的，其返回值是 p2 所指向元素和 p1 所指向元素的序號之差（也可以說是 p2 和 p1 之間的元素個數減一）。

表1所示為不同容器的迭代器的功能。

表1：不同容器的迭代器的功能

容器	迭代器功能
vector	隨機訪問
deque	隨機訪問
list	雙向
set / multiset	雙向
map / multimap	雙向
stack	不支持迭代器
queue	不支持迭代器
priority_queue	不支持迭代器

例如，vector 的迭代器是隨機迭代器，因此遍歷 vector 容器有以下幾種做法。下面的程序中，每個循環演示了一種做法。

【實例】遍歷 vector 容器。

1. #include <iostream>
2. #include <vector>
3. using namespace std;
4. int main()
5. {
6. vector<int> v(100); //v被初始化成有100個元素
7. for(int i = 0;i < v.size() ; ++i) //size返回元素個數
8. cout << v[i]; //像普通數組一樣使用vector容器
9. vector<int>::iterator i;
10. for(i = v.begin(); i != v.end (); ++i) //用 != 比較兩個迭代器
11. cout << * i;
12. for(i = v.begin(); i < v.end ();++i) //用 < 比較兩個迭代器
13. cout << * i;
14. i = v.begin();
15. while(i < v.end()) { //間隔一個輸出
16. cout << * i;
17. i += 2; // 隨機訪問迭代器支持 "+= 整數" 的操作
18. }
19. }

list 容器的迭代器是雙向迭代器。假設 v 和 i 的定義如下：

1. list<int> v;
2. list<int>::const_iterator i;

則以下代碼是合法的：

1. for(i=v.begin(); i!=v.end(); ++i)
2. cout << *i;

以下代碼則不合法：

1. for(i=v.begin(); i<v.end(); ++i)
2. cout << *i;

因為雙向迭代器不支持用“<”進行比較。以下代碼也不合法：

1. for(int i=0; i<v.size(); ++i)
2. cout << v[i];

因為 list 不支持隨機訪問迭代器的容器，也不支持用下標隨機訪問其元素。

在 C++ 中，數組也是容器。數組的迭代器就是指針，而且是隨機訪問迭代器。例如，對於數組 int a[10]，int * 類型的指針就是其迭代器。則 a、a+1、a+2 都是 a 的迭代器。

迭代器的輔助函數

STL 中有用於操作迭代器的三個函數模板，它們是：

• advance(p, n)：使迭代器 p 向前或向后移動 n 個元素。
• distance(p, q)：計算兩個迭代器之間的距離，即迭代器 p 經過多少次 + + 操作后和迭代器 q 相等。如果調用時 p 已經指向 q 的后面，則這個函數會陷入死循環。
• iter_swap(p, q)：用於交換兩個迭代器 p、q 指向的值。

要使用上述模板，需要包含頭文件 algorithm。下面的程序演示了這三個函數模板的 用法。

1. #include <list>
2. #include <iostream>
3. #include <algorithm> //要使用操作迭代器的函數模板，需要包含此文件
4. using namespace std;
5. int main()
6. {
7. int a[5] = { 1, 2, 3, 4, 5 };
8. list <int> lst(a, a+5);
9. list <int>::iterator p = lst.begin();
10. advance(p, 2); //p向后移動兩個元素，指向3
11. cout << "1)" << *p << endl; //輸出 1)3
12. advance(p, -1); //p向前移動一個元素，指向2
13. cout << "2)" << *p << endl; //輸出 2)2
14. list<int>::iterator q = lst.end();
15. q--; //q 指向 5
16. cout << "3)" << distance(p, q) << endl; //輸出 3)3
17. iter_swap(p, q); //交換 2 和 5
18. cout << "4)";
19. for (p = lst.begin(); p != lst.end(); ++p)
20. cout << *p << " ";
21. return 0;
22. }

程序的輸出結果是：
1) 3
2) 2
3) 3
4) 1 5 3 4 2

 

https://www.cnblogs.com/hdk1993/p/4419779.html