C++標準庫類型——迭代器

C++標準庫類型——迭代器

基礎介紹

​ 迭代器提供對一個容器中的對象的訪問方法，並且定義了容器中對象的範圍。

​ 迭代器就如同一個指針。事實上，C++的指針也是一種迭代器。但是，迭代器不僅僅是指針，因此你不能認爲它們一定具有地址值。例如，一個數組索引，也可以認爲是一種迭代器。

​ 除了使用下標來訪問 vector 對象的元素外，標準庫還提供了另一種訪問元素的方法：使用迭代（iterator）。

​ 迭代器是一種檢查容器內元素並遍歷元素的數據類型。

​ 標準庫爲每一種標準容器（包括vector）定義了一種迭代器類型。迭代器類型提供了比下標操作更通用化的方法：所有的標準庫容器都定義了相應的迭代器類型，而只有少數的容器支持下標操作。因爲迭代器對所有的容器都適用，現代 C++ 程序更傾向於使用迭代器而不是下標操作訪問容器元素，即使對支持下標操作的vector 類型也是這樣。

容器的iterator 類型

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

 vector<int>::iterator iter;

​ 語句定義了一個名爲 iter 的變量，它的數據類型是 vector<int > 定義的 iterator 類型。每個標準庫容器類型都定義了一個名爲 iterator 的成員，這裏的 iterator 與迭代器實際類型的含義相同。

術語：迭代器和迭代器類型

​ 程序員首次遇到有關迭代器的術語時可能會困惑不解，原因之一是由於同一個術語 iterator 往往表示兩個不同的事物。一般意義上指的是迭代器的概念；而具體而言時指的則是由容器定義的具體的 iterator 類型，如 vector<int>。

​ 重點要理解的是，有許多用作迭代器的類型，這些類型在概念上是相關的。若一種類型支持一組確定的操作（這些操作可用來遍歷容器內的元素，並訪問這些元素的值），我們就稱這種類型爲迭代器。

​ 各容器類都定義了自己的 iterator類型，用於訪問容器內的元素。換句話說，每個容器都定義了一個名爲 iterator 的類型，而這種類型支持（概念上的）迭代器的各種操作。

begin 和 end 操作

​ 每種容器都定義了一對命名爲 begin 和 end 的函數，用於返回迭代器。如果容器中有元素的話，由 begin 返回的迭代器指向第一個元素：

 vector<int>::iterator iter =ivec.begin();

​ 上述語句把 iter 初始化爲由名爲 vector 操作返回的值。假設 vector 不空，初始化後，iter 即指該元素爲 ivec[0]。

​ 由 end 操作返回的迭代器指向 vector 的“末端元素的下一個”。“超出末端迭代器”（off-the-enditerator）。表明它指向了一個不存在的元素。如果 vector 爲空，begin 返回的迭代器與 end 返回的迭代器相同。

​ 由 end 操作返回的迭代器並不指向 vector 中任何實際的元素，相反，它只是起一個哨兵（sentinel）的作用，表示我們已處理完 vector 中所有元素。

vector 迭代器的自增和解引用運算

​ 迭代器類型定義了一些操作來獲取迭代器所指向的元素，並允許程序員將迭代器從一個元素移動到另一個元素。

​ 迭代器類型可使用解引用操作符（dereference operator）（*）來訪問迭代器所指向的元素：

 *iter = 0;

​ 解引用操作符返回迭代器當前所指向的元素。假設 iter 指向 vector 對象ivec 的第一元素，那麼 *iter 和 ivec[0] 就是指向同一個元素。上面這個語句的效果就是把這個元素的值賦爲0。

​ 迭代器使用自增操作符向前移動迭代器指向容器中下一個元素。從邏輯上說，迭代器的自增操作和 int 型對象的自增操作類似。對 int 對象來說，操作結果就是把 int 型值“加 1”，而對迭代器對象則是把容器中的迭代器“向前移動一個位置”。因此，如果 iter 指向第一個元素，則 ++iter 指向第二個元素。

​ 由於 end操作返回的迭代器不指向任何元素，因此不能對它進行解引用或自增操作。

迭代器的其他操作

​ 另一對可執行於迭代器的操作就是比較：用== 或 != 操作符來比較兩個迭代器，如果兩個迭代器對象指向同一個元素，則它們相等，否則就不相等。

迭代器應用的程序示例

假設已聲明瞭一個vector<int> 型的 ivec 變量，要把它所有元素值重置爲 0，可以用下標操作來完成：

// reset all the elements in ivec to 0
for (vector<int>::size_type ix = 0; ix!= ivec.size(); ++ix)
    ivec[ix] = 0;

​ 上述程序用 for 循環遍歷 ivec 的元素，for 循環定義了一個索引 ix ，每循環迭代一次 ix 就自增1。for 循環體將 ivec 的每個元素賦值爲 0。

​ 更典型的做法是用迭代器來編寫循環：

// equivalent loop using iterators to resetall the elements in ivec to 0
for(vector<int>::iterator iter = ivec.begin();iter != ivec.end(); ++iter)
     *iter = 0;  // set element to which iter refers to 0

​ for 循環首先定義了 iter，並將它初始化爲指向 ivec 的第一個元素。for 循環的條件測試 iter 是否與 end 操作返回的迭代器不等。每次迭代 iter 都自增 1，這個 for 循環的效果是從 ivec 第一個元素開始，順序處理 vector 中的每一元素。最後， iter 將指向 ivec 中的最後一個元素，處理完最後一個元素後，iter 再增加 1，就會與 end 操作的返回值相等，在這種情況下，循環終止。

​ for 循環體內的語句用解引用操作符來訪問當前元素的值。和下標操作符一樣，解引用操作符的返回值是一個左值，因此可以對它進行賦值來改變它的值。上述循環的效果就是把 ivec 中所有元素都賦值爲 0。

​ 通過上述對代碼的詳細分析，可以看出這段程序與用下標操作符的版本達到相同的操作效果：從 vector 的第一個元素開始，把 vector 中每個元素都置爲 0。

​ 本節給出的例子程序，如果 vector 爲空，程序是安全的。如果 ivec 爲空，則 begin 返回的迭代器不指向任何元素——由於沒有元素，所以它不能指向任何元素。在這種情況下，從 begin 操作返回的迭代器與從 end 操作返回的迭代器的值相同，因此 for 語句中的測試條件立即失敗。

const_iterator

​ 前面的程序用vector::iterator 改變 vector 中的元素值。每種容器類型還定義了一種名爲 const_iterator 的類型，該類型只能用於讀取容器內元素，但不能改變其值。

​ 當我們對普通 iterator 類型解引用時，得到對某個元素的非 const。而如果我們對const_iterator 類型解引用時，則可以得到一個指向 const 對象的引用，如同任何常量一樣，該對象不能進行重寫。

​ 例如，如果 text 是 vector<string> 類型，程序員想要遍歷它，輸出每個元素，可以這樣編寫程序：

// use const_iterator because we won'tchange the elements
for (vector<string>::const_iteratoriter = text.begin();iter != text.end(); ++iter)
    cout << *iter << endl; // printeach element in text

​ 除了是從迭代器讀取元素值而不是對它進行賦值之外，這個循環與前一個相似。由於這裏只需要藉助迭代器進行讀，不需要寫，這裏把 iter 定義爲 const_iterator 類型。當對 const_iterator 類型解引用時，返回的是一個 const 值。不允許用 const_iterator 進行賦值

 for (vector<string>::const_iteratoriter = text.begin();iter != text.end(); ++ iter)
   *iter = " ";     // error: *iter is const

​ 使用 const_iterator 類型時，我們可以得到一個迭代器，它自身的值可以改變，但不能用來改變其所指向的元素的值。可以對迭代器進行自增以及使用解引用操作符來讀取值，但不能對該元素賦值。

​ 不要把 const_iterator 對象與 const 的 iterator 對象混淆起來。聲明一個 const 迭代器時，必須初始化迭代器。一旦被初始化後，就不能改變它的值：

vector<int> nums(10);  // nums is nonconst
const vector<int>::iterator cit =nums.begin();
*cit = 1; // ok: cit can change its underlying element
++cit; // error: can't change the value of cit

​ const_iterator對象可以用於const vector 或非 const vector，因爲不能改寫元素值。const 迭代器這種類型幾乎沒什麼用處：一旦它被初始化後，只能用它來改寫其指向的元素，但不能使它指向任何其他元素。

const vector<int> nines(10, 9);  // cannot change elements in nines
// error: cit2 could change the element itrefers to and nines is const
const vector<int>::iterator cit2 =nines.begin();
// ok: it can't change an element value, soit can be used with a const vector<int>
vector<int>::const_iterator it =nines.begin();
*it = 10; // error: *it is const
++it;    // ok: it isn't const so we can change its value
// an iterator that cannot write elements
vector<int>::const_iterator
// an iterator whose value cannot change
constvector<int>::iterator

迭代器的算術操作

​ 除了一次移動迭代器的一個元素的增量操作符外，vector 迭代器（其他標準庫容器迭代器很少）也支持其他的算術操作。這些操作稱爲迭代器算術操作（iterator arithmetic），包括：

iter + n
iter - n

​ 可以對迭代器對象加上或減去一個整型值。這樣做將產生一個新的迭代器，其位置在 iter 所指元素之前（加）或之後（減） n 個元素的位置。加或減之後的結果必須指向 iter 所指 vector 中的某個元素，或者是 vector 末端的後一個元素。加上或減去的值的類型應該是 vector 的 size_type 或 difference_type 類型）。

iter1 - iter2

​ 該表達式用來計算兩個迭代器對象的距離，該距離是名爲 difference_type 的 signed 類型 size_type 的值，這裏的 difference_type 是 signed 類型，因爲減法運算可能產生負數的結果。該類型可以保證足夠大以存儲任何兩個迭代器對象間的距離。iter1 與 iter2 兩者必須都指向同一 vector 中的元素，或者指向 vector 末端之後的下一個元素。

​ 可以用迭代器算術操作來移動迭代器直接指向某個元素，例如，下面語句直接定位於 vector 中間元素：

 vector<int>::iterator mid = vi.begin() +vi.size() / 2;

​ 上述代碼用來初始化 mid 使其指向 vi 中最靠近正中間的元素。這種直接計算迭代器的方法，與用迭代器逐個元素自增操作到達中間元素的方法是等價的，但前者的效率要高得多。

​ 任何改變 vector 長度的操作都會使已存在的迭代器失效。例如，在調用 push_back 之後，就不能再信賴指向 vector 的迭代器的值了。