C++ STL迭代器使用詳解

寫在前面，迭代器這種東西，就是為了使訪問簡單！！

容器：：iterator iter;

for(iter= 容器.begin();iter!=容器.end();iter++){

cout<<*iter或者是 iter->first等等之類的 //迭代器就是這麼個套路

}

然後就是set，set就是一個集合，僅此而已，而其他的，像是map比較有意思，提供了兩種資料結構的對應，而其他的我們不要簡單的認為是佇列和棧，我們要認為這是一種容器，能夠包含多種資料結構，用了這種思想，我們就會想的更明白

下面給出摘抄下來的正文：

指標與陣列

指標與其它資料結構呢？比如說連結串列？

儲存空間是非連續的。不能通過對指向這種資料結構的指標做累加來遍歷。

能不能提供一個行為類似指標的類，來對非陣列的資料結構進行遍歷呢？這樣我們就能夠以同樣的方式來遍歷所有資料結構（容器）。

迭代器(Iterator)是指標(pointer)的泛化，它允許程式設計師以相同的方式處理不同的資料結構(容器)。STL中有五種型別的迭代器，它們分別滿足一定的要求。不同的迭代器要求定義的操作不一樣。

箭頭表示左邊的迭代器一定滿足右邊迭代器需要的條件。

下面的圖表畫出了這幾種：

input output
\/
forward
|
bidirectional
|
random access

要注意，上面這圖表並不是表明它們之間的繼承關係：而只是描述了迭代器的種類和介面。處於圖表下層的迭代器都是相對於處於圖表上層迭代器的擴張集。例如：forward迭代器不但擁有input和output迭代器的所有功能，還擁有更多的功能。

比如某個演算法需要一個雙向迭代器(Bidirctional Iterator)，你可以把一個任意存取迭代器(Random Access Iterator)作為引數；但反之不行。

迭代器iterator 提供了一種一般化的方法對順序或關聯容器型別中的每個元素進行連續訪問

例如，假設iter為任意容器型別的一個iterator，則++iter 表示向前移動迭代器使其指向容器的下一個元素，而*iter 返回iterator 指向元素的值，每種容器型別都提供一個begin()和一個end()成員函式。

begin()返回一個iterator 它指向容器的第一個元素

end()返回一個iterator 它指向容器的末元素的下一個位置

通過迭代器，我們可以用相同的方式來訪問、遍歷容器。

不同容器提供自己的迭代器，所以不同迭代器具有不同的能力。

迭代器的作用：

能夠讓迭代器與演算法不干擾的相互發展，最後又能無間隙的粘合起來。
過載了*，++，＝＝，！＝，＝運算子。用以操作複雜的資料結構。
容器提供迭代器，演算法使用迭代器。

各個迭代器的功能如下：

迭代器類別	說明
輸入	從容器中讀取元素。輸入迭代器只能一次讀入一個元素向前移動，輸入迭代器只支援一遍演算法，同一個輸入迭代器不能兩遍遍歷一個序列
輸出	向容器中寫入元素。輸出迭代器只能一次一個元素向前移動。輸出迭代器只支援一遍演算法，統一輸出迭代器不能兩次遍歷一個序列
正向	組合輸入迭代器和輸出迭代器的功能，並保留在容器中的位置
雙向	組合正向迭代器和逆向迭代器的功能，支援多遍演算法
隨機訪問	組合雙向迭代器的功能與直接訪問容器中任何元素的功能，即可向前向後跳過任意個元素

迭代器的操作：

每種迭代器均可進行包括表中前一種迭代器可進行的操作。

迭代器操作	說明
所有迭代器
p++	後置自增迭代器
++p	前置自增迭代器
輸入迭代器
*p	復引用迭代器，作為右值
p=p1	將一個迭代器賦給另一個迭代器
p==p1	比較迭代器的相等性
p!=p1	比較迭代器的不等性
輸出迭代器
*p	復引用迭代器，作為左值
p=p1	將一個迭代器賦給另一個迭代器
正向迭代器	提供輸入輸出迭代器的所有功能
雙向迭代器
--p	前置自減迭代器
p--	後置自減迭代器
隨機迭代器
p+=i	將迭代器遞增i位
p-=i	將迭代器遞減i位
p+i	在p位加i位後的迭代器
p-i	在p位減i位後的迭代器
p[i]	返回p位元素偏離i位的元素引用
p<p1	如果迭代器p的位置在p1前，返回true，否則返回false
p<=p1	p的位置在p1的前面或同一位置時返回true，否則返回false
p>p1	如果迭代器p的位置在p1後，返回true，否則返回false
p>=p1	p的位置在p1的後面或同一位置時返回true，否則返回false

只有順序容器和關聯容器支援迭代器遍歷，各容器支援的迭代器的類別如下：

容器	支援的迭代器類別	說明
vector	隨機訪問	一種隨機訪問的陣列型別，提供了對陣列元素進行快速隨機訪問以及在序列尾部進行快速的插入和刪除操作的功能。可以再需要的時候修改其自身的大小
deque	隨機訪問	一種隨機訪問的陣列型別，提供了序列兩端快速進行插入和刪除操作的功能。可以再需要的時候修改其自身的大小
list	雙向	一種不支援隨機訪問的陣列型別，插入和刪除所花費的時間是固定的，與位置無關。
set	雙向	一種隨機存取的容器，其關鍵字和資料元素是同一個值。所有元素都必須具有惟一值。
multiset	雙向	一種隨機存取的容器，其關鍵字和資料元素是同一個值。可以包含重複的元素。
map	雙向	一種包含成對數值的容器，一個值是實際資料值，另一個是用來尋找資料的關鍵字。一個特定的關鍵字只能與一個元素關聯。
multimap	雙向	一種包含成對數值的容器，一個值是實際資料值，另一個是用來尋找資料的關鍵字。一個關鍵字可以與多個數據元素關聯。
stack	不支援	介面卡容器型別，用vector，deque或list物件建立了一個先進後出容器
queue	不支援	介面卡容器型別，用deque或list物件建立了一個先進先出容器
priority_queue	不支援	介面卡容器型別，用vector或deque物件建立了一個排序佇列

下面列舉了些例子說明各個容器的用法：

1、vector

#include <iostream>

#include <vector>

intmain()

{

std::vector<char> charVector;

intx;

for(x=0; x<10; ++x)

charVector.push_back(65 + x);

intsize = charVector.size();

for(x=0; x<size; ++x)

{

std::vector<char>::iterator start =

charVector.begin();

charVector.erase(start);

std::vector<char>::iterator iter;

for(iter = charVector.begin();

iter != charVector.end(); iter++)

{

std::cout << *iter;

}

std::cout << std::endl;

}

return0;

}

2、deque

#include <iostream>

#include <deque>

intmain()

{

std::deque<char> charDeque;

intx;

for(x=0; x<10; ++x)

charDeque.push_front(65 + x);

intsize = charDeque.size();

for(x=0; x<size; ++x)

{

std::deque<char>::iterator start =

charDeque.begin();

charDeque.erase(start);

std::deque<char>::iterator iter;

for(iter = charDeque.begin();

iter != charDeque.end(); iter++)

{

std::cout << *iter;

}

std::cout << std::endl;

}

return0;

}

3、list

#include <iostream>

#include <list>

intmain()

{

// Create and populate the list.

intx;

std::list<char> charList;

for(x=0; x<10; ++x)

charList.push_front(65 + x);

// Display contents of list.

std::cout << "Original list: ";

std::list<char>::iterator iter;

for(iter = charList.begin();

iter != charList.end(); iter++)

{

std::cout << *iter;

//char ch = *iter;

//std::cout << ch;

}

std::cout << std::endl;

// Insert five Xs into the list.

std::list<char>::iterator start = charList.begin();

charList.insert(++start, 5, 'X');

// Display the result.

std::cout << "Resultant list: ";

for(iter = charList.begin();

iter != charList.end(); iter++)

{

std::cout << *iter;

//char ch = *iter;

//std::cout << ch;

}

return0;

}

4、set

#include <iostream>

#include <set>

intmain()

{

// Create the set object.

std::set<char> charSet;

// Populate the set with values.

charSet.insert('E');

charSet.insert('D');

charSet.insert('C');

charSet.insert('B');

charSet.insert('A');

// Display the contents of the set.

std::cout << "Contents of set: " << std::endl;

std::set<char>::iterator iter;

for(iter = charSet.begin(); iter != charSet.end(); iter++)

std::cout << *iter << std::endl;

std::cout << std::endl;

// Find the D.

iter = charSet.find('D');

if(iter == charSet.end())

std::cout << "Element not found.";

else

std::cout << "Element found: " << *iter;

return0;

}

5、multiset

#include <iostream>

#include <set>

intmain()

{

// Create the first set object.

std::multiset<char> charMultiset1;

// Populate the multiset with values.

charMultiset1.insert('E');

charMultiset1.insert('D');

charMultiset1.insert('C');

charMultiset1.insert('B');

charMultiset1.insert('A');

charMultiset1.insert('B');

charMultiset1.insert('D');

// Display the contents of the first multiset.

std::cout << "Contents of first multiset: " << std::endl;

std::multiset<char>::iterator iter;

for(iter = charMultiset1.begin();

iter != charMultiset1.end(); iter++)

std::cout << *iter << std::endl;

std::cout << std::endl;

// Create the second multiset object.

std::multiset<char> charMultiset2;

// Populate the multiset with values.

charMultiset2.insert('J');

charMultiset2.insert('I');

charMultiset2.insert('H');

charMultiset2.insert('G');

charMultiset2.insert('F');

charMultiset2.insert('G');

charMultiset2.insert('I');

// Display the contents of the second multiset.

std::cout << "Contents of second multiset: "

<< std::endl;

for(iter = charMultiset2.begin();

iter != charMultiset2.end(); iter++)

std::cout << *iter << std::endl;

std::cout << std::endl;

// Compare the sets.

if(charMultiset1 == charMultiset2)

std::cout << "set1 == set2";

elseif(charMultiset1 < charMultiset2)

std::cout << "set1 < set2";

elseif(charMultiset1 > charMultiset2)

std::cout << "set1 > set2";

return0;

}

6、map

#include <iostream>

#include <map>

typedefstd::map<int,char> MYMAP;

intmain()

{

// Create the first map object.

MYMAP charMap1;

// Populate the first map with values.

charMap1[1] = 'A';

charMap1[4] = 'D';

charMap1[2] = 'B';

charMap1[5] = 'E';

charMap1[3] = 'C';

// Display the contents of the first map.

std::cout << "Contents of first map: " << std::endl;

MYMAP::iterator iter;

for(iter = charMap1.begin();

iter != charMap1.end(); iter++)

{

std::cout << (*iter).first << " --> ";

std::cout << (*iter).second << std::endl;

}

std::cout << std::endl;

// Create the second map object.

MYMAP charMap2;

// Populate the first map with values.

charMap2[1] = 'F';

charMap2[4] = 'I';

charMap2[2] = 'G';

charMap2[5] = 'J';

charMap2[3] = 'H';

// Display the contents of the second map.

std::cout << "Contents of second map: " << std::endl;

for(iter = charMap2.begin();

iter != charMap2.end(); iter++)

{

std::cout << (*iter).first << " --> ";

std::cout << (*iter).second << std::endl;

}

std::cout << std::endl;

// Compare the maps.

if(charMap1 == charMap2)

std::cout << "map1 == map2";

elseif(charMap1 < charMap2)

std::cout << "map1 < map2";

elseif(charMap1 > charMap2)

std::cout << "map1 > map2";

return0;

}

7、multimap

#include <iostream>

#include <map>

typedefstd::multimap<int,char> MYMAP;

intmain()

{

// Create the first multimap object.

MYMAP charMultimap;

// Populate the multimap with values.

charMultimap.insert(MYMAP::value_type(1,'A'));

charMultimap.insert(MYMAP::value_type(4,'C'));

charMultimap.insert(MYMAP::value_type(2,'B'));

charMultimap.insert(MYMAP::value_type(7,'E'));

charMultimap.insert(MYMAP::value_type(5,'D'));

charMultimap.insert(MYMAP::value_type(3,'B'));

charMultimap.insert(MYMAP::value_type(6,'D'));

// Display the contents of the first multimap.

std::cout << "Contents of first multimap: " << std::endl;

MYMAP::iterator iter;

for(iter = charMultimap.begin();

iter != charMultimap.end(); iter++)

{

std::cout << (*iter).first << " --> ";

std::cout << (*iter).second << std::endl;

}

std::cout << std::endl;

// Create the second multimap object.

MYMAP charMultimap2;

// Populate the second multimap with values.

charMultimap2.insert(MYMAP::value_type(1,'C'));

charMultimap2.insert(MYMAP::value_type(4,'F'));

charMultimap2.insert(MYMAP::value_type(2,'D'));

charMultimap2.insert(MYMAP::value_type(7,'E'));

charMultimap2.insert(MYMAP::value_type(5,'F'));

charMultimap2.insert(MYMAP::value_type(3,'E'));

charMultimap2.insert(MYMAP::value_type(6,'G'));

// Display the contents of the second multimap.

std::cout << "Contents of second multimap: " << std::endl;

for(iter = charMultimap2.begin();

iter != charMultimap2.end(); iter++)

{

std::cout << (*iter).first << " --> ";

std::cout << (*iter).second << std::endl;

}

std::cout << std::endl;

// Compare the multimaps.

if(charMultimap == charMultimap2)

std::cout << "multimap1 == multimap2";

elseif(charMultimap < charMultimap2)

std::cout << "multimap1 < multimap2";

elseif(charMultimap > charMultimap2)

std::cout << "multimap1 > multimap2";

return0;

}

8、stack

#include <iostream>

#include <list>

#include <stack>

intmain()

{

std::stack<int, std::list<int> > intStack;

intx;

std::cout << "Values pushed onto stack:"

<< std::endl;

for(x=1; x<11; ++x)

{

intStack.push(x*100);

std::cout << x*100 << std::endl;

}

std::cout << "Values popped from stack:"

<< std::endl;

intsize = intStack.size();

for(x=0; x<size; ++x)

{

std::cout << intStack.top() << std::endl;

intStack.pop();

}

return0;

}

9、queue

#include <iostream>

#include <list>

#include <queue>

intmain()

{

std::queue<int, std::list<int> > intQueue;

intx;

std::cout << "Values pushed onto queue:"

<< std::endl;

for(x=1; x<11; ++x)

{

intQueue.push(x*100);

std::cout << x*100 << std::endl;

}

std::cout << "Values removed from queue:"

<< std::endl;

intsize = intQueue.size();

for(x=0; x<size; ++x)

{

std::cout << intQueue.front() << std::endl;

intQueue.pop();

}

return0;

}

10、priority_queue

#include <iostream>

#include <list>

#include <queue>

intmain()

{

std::priority_queue<int, std::vector<int>,std::greater<int> > intPQueue;

intx;

intPQueue.push(400);

intPQueue.push(100);

intPQueue.push(500);

intPQueue.push(300);

intPQueue.push(200);

std::cout << "Values removed from priority queue:"

<< std::endl;

intsize = intPQueue.size();

for(x=0; x<size; ++x)

{

std::cout << intPQueue.top() << std::endl;

intPQueue.pop();

}

return0;

}

指標與陣列

指標與其它資料結構呢？比如說連結串列？

儲存空間是非連續的。不能通過對指向這種資料結構的指標做累加來遍歷。

能不能提供一個行為類似指標的類，來對非陣列的資料結構進行遍歷呢？這樣我們就能夠以同樣的方式來遍歷所有資料結構（容器）。

箭頭表示左邊的迭代器一定滿足右邊迭代器需要的條件。

下面的圖表畫出了這幾種：

input output
\/
forward
|
bidirectional
|
random access

比如某個演算法需要一個雙向迭代器(Bidirctional Iterator)，你可以把一個任意存取迭代器(Random Access Iterator)作為引數；但反之不行。

迭代器iterator 提供了一種一般化的方法對順序或關聯容器型別中的每個元素進行連續訪問

begin()返回一個iterator 它指向容器的第一個元素

end()返回一個iterator 它指向容器的末元素的下一個位置

通過迭代器，我們可以用相同的方式來訪問、遍歷容器。

不同容器提供自己的迭代器，所以不同迭代器具有不同的能力。

迭代器的作用：

能夠讓迭代器與演算法不干擾的相互發展，最後又能無間隙的粘合起來。
過載了*，++，＝＝，！＝，＝運算子。用以操作複雜的資料結構。
容器提供迭代器，演算法使用迭代器。

各個迭代器的功能如下：

迭代器類別	說明
輸入	從容器中讀取元素。輸入迭代器只能一次讀入一個元素向前移動，輸入迭代器只支援一遍演算法，同一個輸入迭代器不能兩遍遍歷一個序列
輸出	向容器中寫入元素。輸出迭代器只能一次一個元素向前移動。輸出迭代器只支援一遍演算法，統一輸出迭代器不能兩次遍歷一個序列
正向	組合輸入迭代器和輸出迭代器的功能，並保留在容器中的位置
雙向	組合正向迭代器和逆向迭代器的功能，支援多遍演算法
隨機訪問	組合雙向迭代器的功能與直接訪問容器中任何元素的功能，即可向前向後跳過任意個元素

迭代器的操作：

每種迭代器均可進行包括表中前一種迭代器可進行的操作。

迭代器操作	說明
所有迭代器
p++	後置自增迭代器
++p	前置自增迭代器
輸入迭代器
*p	復引用迭代器，作為右值
p=p1	將一個迭代器賦給另一個迭代器
p==p1	比較迭代器的相等性
p!=p1	比較迭代器的不等性
輸出迭代器
*p	復引用迭代器，作為左值
p=p1	將一個迭代器賦給另一個迭代器
正向迭代器	提供輸入輸出迭代器的所有功能
雙向迭代器
--p	前置自減迭代器
p--	後置自減迭代器
隨機迭代器
p+=i	將迭代器遞增i位
p-=i	將迭代器遞減i位
p+i	在p位加i位後的迭代器
p-i	在p位減i位後的迭代器
p[i]	返回p位元素偏離i位的元素引用
p<p1	如果迭代器p的位置在p1前，返回true，否則返回false
p<=p1	p的位置在p1的前面或同一位置時返回true，否則返回false
p>p1	如果迭代器p的位置在p1後，返回true，否則返回false
p>=p1	p的位置在p1的後面或同一位置時返回true，否則返回false

只有順序容器和關聯容器支援迭代器遍歷，各容器支援的迭代器的類別如下：

容器	支援的迭代器類別	說明
vector	隨機訪問	一種隨機訪問的陣列型別，提供了對陣列元素進行快速隨機訪問以及在序列尾部進行快速的插入和刪除操作的功能。可以再需要的時候修改其自身的大小
deque	隨機訪問	一種隨機訪問的陣列型別，提供了序列兩端快速進行插入和刪除操作的功能。可以再需要的時候修改其自身的大小
list	雙向	一種不支援隨機訪問的陣列型別，插入和刪除所花費的時間是固定的，與位置無關。
set	雙向	一種隨機存取的容器，其關鍵字和資料元素是同一個值。所有元素都必須具有惟一值。
multiset	雙向	一種隨機存取的容器，其關鍵字和資料元素是同一個值。可以包含重複的元素。
map	雙向	一種包含成對數值的容器，一個值是實際資料值，另一個是用來尋找資料的關鍵字。一個特定的關鍵字只能與一個元素關聯。
multimap	雙向	一種包含成對數值的容器，一個值是實際資料值，另一個是用來尋找資料的關鍵字。一個關鍵字可以與多個數據元素關聯。
stack	不支援	介面卡容器型別，用vector，deque或list物件建立了一個先進後出容器
queue	不支援	介面卡容器型別，用deque或list物件建立了一個先進先出容器
priority_queue	不支援	介面卡容器型別，用vector或deque物件建立了一個排序佇列

下面列舉了些例子說明各個容器的用法：

1、vector

#include <iostream>

#include <vector>

intmain()

{

std::vector<char> charVector;

intx;

for(x=0; x<10; ++x)

charVector.push_back(65 + x);

intsize = charVector.size();

for(x=0; x<size; ++x)

{

std::vector<char>::iterator start =

charVector.begin();

charVector.erase(start);

std::vector<char>::iterator iter;

for(iter = charVector.begin();

iter != charVector.end(); iter++)

{

std::cout << *iter;

}

std::cout << std::endl;

}

return0;

}

2、deque

#include <iostream>

#include <deque>

intmain()

{

std::deque<char> charDeque;

intx;

for(x=0; x<10; ++x)

charDeque.push_front(65 + x);

intsize = charDeque.size();

for(x=0; x<size; ++x)

{

std::deque<char>::iterator start =

charDeque.begin();

charDeque.erase(start);

std::deque<char>::iterator iter;

for(iter = charDeque.begin();

iter != charDeque.end(); iter++)

{

std::cout << *iter;

}

std::cout << std::endl;

}

return0;

}

3、list

#include <iostream>

#include <list>

intmain()

{

// Create and populate the list.

intx;

std::list<char> charList;

for(x=0; x<10; ++x)

charList.push_front(65 + x);

// Display contents of list.

std::cout << "Original list: ";

std::list<char>::iterator iter;

for(iter = charList.begin();

iter != charList.end(); iter++)

{

std::cout << *iter;

//char ch = *iter;

//std::cout << ch;

}

&nbs


              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    C++ STL迭代器使用詳解
       
 
 寫在前面，迭代器這種東西，就是為了使訪問簡單！！ 
 容器：：iterator iter; 
 for(iter= 容器.begin();iter!=容器.end();iter++){ 
 cout<<*iter或者是 iter->first等等之類的      

  
 

    

    
    c++迭代器詳解（一）：back_inserter, front_inserter,inserter
      
                
1.stl迭代器之配接器（ Iterator Adapters）
迭代器（Iterators）是一個純抽象的概念：任何東西，只要其行為類似迭代器，它就是一個迭代器.也就是說，只有具備有迭代器的四種基本操作：取值（*），遞增（++）
比較（== !=） 賦值（=）它就是迭代器 

  
 

    

    
    C++ STL迭代器失效情況總結
       
 
 本文轉自：https://www.cnblogs.com/Commence/p/7526421.html 
 1.對於序列式容器：vector，queue（C++的序列式容器有vector、deque、list、forward_list、array和string幾種）等，序列式容器就是陣列式容器，刪 

  
 

    

    
    python迭代器詳解
      迭代器 
迭代是訪問集合元素的一種方式。迭代器是一個可以記住遍歷的位置的物件。迭代器物件從集合的第一個元素開始訪問，直到所有的元素被訪問完結束。迭代器只能往前不會後退。 
1. 可迭代物件 
我們已經知道可以對list、tuple、str等型別的資料使用for...in...的迴圈語法從其中依次拿到資料進行使 

  
 

    

    
    Java中 ( Iterator ) 迭代器 詳解 ( JDK8原始碼 )
       
 
 Java集合框架的集合類，我們有時候稱之為容器。容器的種類有很多種，比如ArrayList、LinkedList、HashSet...，每種容器都有自己的特點，ArrayList底層維護的是一個數組；LinkedList是連結串列結構的；HashSet依賴的是雜湊表，每種容器都有自己特有的資料結構。 

  
 

    

    
    Python學習——for迴圈，生成器，迭代器詳解
       
  
  
 
 
  文章目錄
  
   Python的for迴圈
   
    for迴圈示例
    
     List 列表迴圈
     dict 字典迴圈
     列表生成式
    
   
   生成器
   
    列表式生成器
    函式式生成器
    生成器式生產者消費 

  
 

    

    
    C++ STL 迭代器刪除問題總結
      map<int,int>::iterator iter;
for(iter = testMap.begin(); iter != testMap.end(); iter++)
{
    printf("%d " , iter->second );
    if( iter->seco 

  
 

    

    
    C++進階與拔高（四）（C++ STL迭代器）
      
                第二章 C++ STL

        本章節所介紹的C++ STL主要基於三個內容：迭代、演算法和容器。所參考的資料均來自於CSDN部落格以及P.J.PLAUGER所著的《C++ STL中文版》。主要的參考文獻將在本書最後給出。

2.1 C++ STL簡介

      

  
 

    

    
    python中的當資料量非常大的時候，節省記憶體空間的設定方式------------------------生成器與迭代器詳解，內附示例程式碼
      
                鋪墊部分，首先，我們先來講一下列表生成式，如下所示

>>> [i*2 for i in range(10)]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

這就是列表生成式，現在的資料量比較小，並不能看出什麼，當把range(1 

  
 

    

    
    C++ STL 迭代器在string類中的使用方法
      
								
								            
						
                //以下例子說明迭代器在string類中的使用方法
#include <iostream>
#include <string>
#include <algorithm> 

  
 

    

    
    C++ STL迭代器原理和簡單實現
      ### 1. 迭代器簡介
為了提高C++程式設計的效率，STL（Standard Template Library）中提供了許多容器，包括vector、list、map、set等。然而有些容器（vector）可以通過下標索引的方式訪問容器裡面的資料，但是大部分的容器（list、map、set）不能使用這種方式 

  
 

    

    
    STL 迭代器（iterator）詳解
      背景：指標可以用來遍歷儲存空間連續的資料結構，但是對於儲存空間非連續的，就需要尋找一個行為類似指標的類，來對非陣列的資料結構進行遍歷。因此，我們引入迭代器概念。 
  
一、迭代器（iterator）介紹 
迭代器（Iterator）是一種檢查容器內元素並遍歷元素的資料型別。迭代器是指標的泛化，它允 

  
 

    

    
    【C++】：STL迭代器使用
      
                

僅僅轉了迭代器的功能，該文裡還有例子。然後 搜這個的原因是因為list裡迭代器不可 += 只可++||--想知道下為什麼。以下為轉載內容。









迭代器的作用：

能夠讓迭代器與演算法不干擾的相互發展，最後又能無間隙的粘合起來。
	過載了*，++，＝＝，！＝， 

  
 

    

    
    C++標準模板庫(STL)迭代器的原理與實現
      
							
							
							引言

迭代器(iterator)是一種抽象的設計理念，通過迭代器可以在不瞭解容器內部原理的情況下遍歷容器。除此之外，STL中迭代器一個最重要的作用就是作為容器(vector,list等)與STL演算法的粘結劑，只要容器提供迭代器的介面，同一套演算法程式碼可以利 

  
 

    

    
    C++之STL迭代器（iterator）
      

1、vector
#include <iostream>
#include <vector>

int main()
{
    std::vector<char> charVector;

    int x;
    for (x=0; x&l 

  
 

    

    
    迭代器 可迭代物件 詳解 python iterator
      
                1.迭代器（iterator），是可以用直接用for 或其他迭代工具遍歷的東西。2.可迭代物件（iterable），先需要內建函式iter()轉化成迭代器，然後才可以用for或其他迭代工具遍歷。常見的可迭代物件有list,set,dict,range物件（python3）等3 

  
 

    

    
    C++: STL叠代器及叠代器失效問題
      內存分配   csdn   i/o   priority   存在   層次   什麽   rst   clas   轉載至：http://blog.csdn.net/wangshihui512/article/details/9791517
 
叠代器失效： 典型的叠代器失效. 
首先對於vector而言， 

  
 

    

    
    C++STL之Vector向量詳解,用法和例子 一起學習 一起加油
                                                  & 

  
 

    

    
    可迭代物件 詳解
      可迭代物件詳解 

 1.可迭代物件
 

 我們已經知道可以對list、tuple、dict、set、str等型別的資料使用for...in...的迴圈語法從其中依次拿到資料進行使用，我們把這樣的過程稱為遍歷，也叫迭代。
 

 把可以通過for...in...這類語句迭代讀取一條資料供我們使用的物件稱之為 

  
 

    

    
    學習筆記 c++ （迭代器）
      
                迭代器

迭代器是演算法和容器的橋樑
	迭代器用作訪問容器中的元素
		演算法不直接操作容器中的資料，而是通過迭代器間接操作
	
	演算法和容器獨立
	增加新的演算法，無需影響容器的實現
		增加新的容器，原有的演算法也能適用
	
輸入流迭代器和輸出流迭代器


	輸入流迭代


        
      
    
    
  
    搜尋
    
        
      
      
    
  
 
  
  
    基礎教學
     
    Mysql入門  
     Sql入門 
      Android入門 
       Docker入門 
        Go語言入門 
         Ruby程式入門 
          Python入門 
           Python進階 
            Django入門 
             Python爬蟲入門 
             
      
      
  
   
  
    最近訪問
    
  	      
  
      
    
  

 

 


  
    
      
        
          首頁
前端設計
程式設計
免費資源
實用技巧
資料庫
資訊
字典
        
          Copyright © 2002-2020  程式人生 796T.COM All rights reserved.

C++ STL迭代器使用詳解

C++ STL迭代器使用詳解

c++迭代器詳解（一）：back_inserter, front_inserter,inserter

C++ STL迭代器失效情況總結

python迭代器詳解

Java中 ( Iterator ) 迭代器詳解 ( JDK8原始碼 )

Python學習——for迴圈，生成器，迭代器詳解

C++ STL 迭代器刪除問題總結

C++進階與拔高（四）（C++ STL迭代器）

python中的當資料量非常大的時候，節省記憶體空間的設定方式------------------------生成器與迭代器詳解，內附示例程式碼

C++ STL 迭代器在string類中的使用方法

C++ STL迭代器原理和簡單實現

STL 迭代器（iterator）詳解

【C++】：STL迭代器使用

C++標準模板庫(STL)迭代器的原理與實現

C++之STL迭代器（iterator）

迭代器可迭代物件詳解 python iterator

C++: STL叠代器及叠代器失效問題

C++STL之Vector向量詳解,用法和例子一起學習一起加油

可迭代物件詳解

學習筆記 c++ （迭代器）