【C++】：STL迭代器使用详解，很好很详细

最新推荐文章于 2024-03-20 13:08:16 发布
最新推荐文章于 2024-03-20 13:08:16 发布
阅读量3.4w 收藏 140
点赞数 25
分类专栏： C++

写在前面，迭代器这种东西，就是为了使访问简单！！

容器：：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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
#include <vector>
 
int main()
{
     std::vector< char > charVector;
 
     int x;
     for (x=0; x<10; ++x)
         charVector.push_back(65 + x);
 
     int size = 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;
     }
 
     return 0;
}

2、deque

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
#include <deque>
 
int main()
{
     std::deque< char > charDeque;
     int x;
     for (x=0; x<10; ++x)
         charDeque.push_front(65 + x);
 
     int size = 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;
     }
 
     return 0;
}

3、list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <iostream>
#include <list>
 
int main()
{
     // Create and populate the list.
     int x;
     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;
     }
     
     return 0;
}

4、set

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <iostream>
#include <set>
 
int main()
{
     // 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;
 
     return 0;
}

5、multiset

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <iostream>
#include <set>
 
int main()
{
     // 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" ;
     else if (charMultiset1 < charMultiset2)
         std::cout << "set1 < set2" ;
     else if (charMultiset1 > charMultiset2)
         std::cout << "set1 > set2" ;
     
     return 0;
}

6、map

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <iostream>
#include <map>
 
typedef std::map< int , char > MYMAP;
 
int main()
{
     // 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" ;
     else if (charMap1 < charMap2)
         std::cout << "map1 < map2" ;
     else if (charMap1 > charMap2)
         std::cout << "map1 > map2" ;
     
     return 0;
}

7、multimap

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <iostream>
#include <map>
 
typedef std::multimap< int , char > MYMAP;
 
int main()
{
     // 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" ;
     else if (charMultimap < charMultimap2)
         std::cout << "multimap1 < multimap2" ;
     else if (charMultimap > charMultimap2)
         std::cout << "multimap1 > multimap2" ;
     
     return 0;
}

8、stack

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
#include <list>
#include <stack>
 
int main()
{
     std::stack< int , std::list< int > > intStack;
 
     int x;
     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;
     int size = intStack.size();
     for (x=0; x<size; ++x)
     {
         std::cout << intStack.top() << std::endl;
         intStack.pop();
     }
 
     return 0;
}

9、queue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
#include <list>
#include <queue>
 
int main()
{
     std::queue< int , std::list< int > > intQueue;
 
     int x;
     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;
     int size = intQueue.size();
     for (x=0; x<size; ++x)
     {
         std::cout << intQueue.front() << std::endl;
         intQueue.pop();
     }
 
     return 0;
}

10、priority_queue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <iostream>
#include <list>
#include <queue>
 
int main()
{
     std::priority_queue< int , std::vector< int >,std::greater< int > > intPQueue;
     int x;
     intPQueue.push(400);
     intPQueue.push(100);
     intPQueue.push(500);
     intPQueue.push(300);
     intPQueue.push(200);
 
     std::cout << "Values removed from priority queue:"
               << std::endl;
     int size = intPQueue.size();
     for (x=0; x<size; ++x)
     {
         std::cout << intPQueue.top() << std::endl;
         intPQueue.pop();
     }
 
     return 0;
}

指针与数组
指针与其它数据结构呢？比如说链表？
存储空间是非连续的。不能通过对指向这种数据结构的指针做累加来遍历。
能不能提供一个行为类似指针的类，来对非数组的数据结构进行遍历呢？这样我们就能够以同样的方式来遍历所有数据结构（容器）。
迭代器(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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
#include <vector>
 
int main()
{
     std::vector< char > charVector;
 
     int x;
     for (x=0; x<10; ++x)
         charVector.push_back(65 + x);
 
     int size = 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;
     }
 
     return 0;
}

2、deque

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
#include <deque>
 
int main()
{
     std::deque< char > charDeque;
     int x;
     for (x=0; x<10; ++x)
         charDeque.push_front(65 + x);
 
     int size = 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;
     }
 
     return 0;
}

3、list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <iostream>
#include <list>
 
int main()
{
     // Create and populate the list.
     int x;
     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;
     }
     
     return 0;
}

4、set

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <iostream>
#include <set>
 
int main()
{
     // 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;
 
     return 0;
}

5、multiset

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <iostream>
#include <set>
 
int main()
{
     // 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" ;
     else if (charMultiset1 < charMultiset2)
         std::cout << "set1 < set2" ;
     else if (charMultiset1 > charMultiset2)
         std::cout << "set1 > set2" ;
     
     return 0;
}

6、map

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <iostream>
#include <map>
 
typedef std::map< int , char > MYMAP;
 
int main()
{
     // 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" ;
     else if (charMap1 < charMap2)
         std::cout << "map1 < map2" ;
     else if (charMap1 > charMap2)
         std::cout << "map1 > map2" ;
     
     return 0;
}

7、multimap

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <iostream>
#include <map>
 
typedef std::multimap< int , char > MYMAP;
 
int main()
{
     // 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" ;
     else if (charMultimap < charMultimap2)
         std::cout << "multimap1 < multimap2" ;
     else if (charMultimap > charMultimap2)
         std::cout << "multimap1 > multimap2" ;
     
     return 0;
}

8、stack

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
#include <list>
#include <stack>
 
int main()
{
     std::stack< int , std::list< int > > intStack;
 
     int x;
     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;
     int size = intStack.size();
     for (x=0; x<size; ++x)
     {
         std::cout << intStack.top() << std::endl;
         intStack.pop();
     }
 
     return 0;
}

9、queue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
#include <list>
#include <queue>
 
int main()
{
     std::queue< int , std::list< int > > intQueue;
 
     int x;
     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;
     int size = intQueue.size();
     for (x=0; x<size; ++x)
     {
         std::cout << intQueue.front() << std::endl;
         intQueue.pop();
     }
 
     return 0;
}

10、priority_queue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <iostream>
#include <list>
#include <queue>
 
int main()
{
     std::priority_queue< int , std::vector< int >,std::greater< int > > intPQueue;
     int x;
     intPQueue.push(400);
     intPQueue.push(100);
     intPQueue.push(500);
     intPQueue.push(300);
     intPQueue.push(200);
 
     std::cout << "Values removed from priority queue:"
               << std::endl;
     int size = intPQueue.size();
     for (x=0; x<size; ++x)
     {
         std::cout << intPQueue.top() << std::endl;
         intPQueue.pop();
     }
 
     return 0;
}
seen_in_hw
关注
  • 25
    点赞
  • 踩
  • 140
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
浅谈c++ stl迭代器失效的问题
12-26
之前看《C++ Primier》的时候，也解到在顺序型窗口里insert/erase会涉及到迭代器失效的问题，并没有深究。今天写程序的时候遇到了这个问题。 1 莫名其妙的Erase 最初我的程序是酱紫的，别说话，我知道这样是有问题的...
C++ 哈希表基本用法
m0_52318340的博客
07-29 1万+
如果现在做哈希表的题目，是因为按专题刷的哈希表的题目，所以会直接用哈希表。但是遇到一道新的题目，没有标签，怎么想到使用哈希表呢？在unordered_set跟unordered_map中删除元素，都用。如果是unordered_map，遍历的时候，可以访键值。在unordered_set中插入元素，可以用。在unordered_map中插入元素，可以使用。，如果之前已经将key存入到hash中，然后通过。注意，在unordered_map中，即使。，hash中还会存在key，也就是说此时。......
C++ 迭代器(iterator)超详解+实例演练
qq_52324409的博客
11-13 3万+
C++ STL 迭代器详解一级目录二级目录三级目录 一级目录 二级目录 三级目录
STL---迭代器
最新发布
xuxianshun666的博客
03-20 631
STL---迭代器
C++的迭代器以及它的用法
galaxyrt的博客
12-05 7614
迭代器：是一种可以遍历容器元素的数据类型，它是一个变量，相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素，通过迭代器就可以读写它指向的元素。从这一点上看，迭代器和指针类似。 迭代器（Iterator）是指针（pointer）的泛化，它允许程序员用相同的方式处理不同的数据结构（容器）。 （1）迭代器类似于C语言里面的指针类型，它提供了对对象的间接访问。 （2）指针是C语言中的知识点，迭代器是C++中的知识点。指针较灵活，迭代器功能较丰富。 （3）迭代器提供一个对容器对象或者strin.
C++中迭代器的详细用法
qq_73554831的博客
10-25 450
迭代器非常有用，可以用于搜索、插入、删除和修改容器中的元素。它们还允许你在不暴露容器的底层实现细节的情况下访问容器中的数据。在修改容器时，要注意迭代器的失效问题。插入或删除元素可能导致迭代器失效，因此在使用迭代器之前要谨慎检查容器的有效性。这会自动遍历容器中的元素，而不需要显式使用迭代器。这会输出容器中的所有元素。
iterator迭代器的使用
06-07 457
部分摘自C++ Primer： 所有的标准库容器类都定义了相应的iterator类型，如vector:vector<int>::iterator iter; 这条语句定义了一个名为iter的变量，它的数据类型是由vector<int>定义的iterator类型。 理解一下：除了使用下标来访问vector对象的元素外，标准库还提供了另一种检测元素的方法：使用迭...
C++学习篇——C++ STL中迭代器介绍
06-29
C++ STL中迭代器介绍 迭代器 迭代器提供对一个容器中的对象的访问方法，并且定义了容器中对象的范围。迭代器就如同一个指针。事实上，C++的指针也是一种迭代器。但是，迭代器不仅仅是指针，因此你不能认为他们一定...
C++STL实验报告-迭代器和非变异算法
12-30
本实验主要练习容器set、multiset、map、multimap的使用方法，插入迭代器、反向迭代器的用法，以及四种非变异算法的基本用法。 实验器材： VScode 实验内容： 一．回顾以上四种容器相关的例题（不作为实验报告内容）...
C++ STL 迭代器 入门
01-14
关于 C++ STL 迭代器 的最佳入门教程之一。 轻松、幽默、干脆、一看就会！却不乏C++编程思想之启发！
C++迭代器（iterator）用法
QiaoLiu___lq的博客
02-17 4255
c++迭代器用法
C++ STL 迭代器（iterator）详解
QtCompany的博客
07-12 1870
指针可以用来遍历连续的数据结构，但是对于存储空间非连续的，就需要寻找一个行为类似指针的类，来对非数组的数据结构进行遍历。因此，我们引入迭代器概念。迭代器（Iterator）是一种检查容器内元素并遍历元素的数据类型。迭代器是指针的泛化，它允许程序员用相同的方式处理不同的数据结构（容器）。所有容器有含有其各自的迭代器型别（iterator types），所以当你使用一般的容器迭代器时，并不需要含入专门的头文件。不过有几种特别的迭代器，例如逆向迭代器，被定义于 中。
C++迭代器的简单使用
qq_38609565的博客
07-13 819
此文为阅读笔记，内容基本出自书中。 1. 基本概念 使用下标访问对象的成员的最基本方法有三种：string对象的字符访问，vector对象的元素访问，迭代器。 迭代器类似于指针类型，也提供了对对象的间接访问。使用迭代器可以访问某个元素，也能从一个元素移动到另外一个元素。迭代器分为有效和无效，有效的迭代器或者指向某个元素，或者指向容器中尾元素的下一个位置，其他所有情况都属于无效。 2. 使用迭代器 有迭代器的类型都拥有名为begin和end的成员，其中begin成员负责返回指...
STL迭代器
weixin_61438881的博客
02-11 2111
目录 一、迭代器 基本概念 （1）内置迭代器的使用 （2）自己模拟迭代器的实现 （3）流型迭代器 二、lambda表达式 （1）基本概念 （2）捕获方式的区别 三、仿函数 包含头文件functional 基本概念 使用 四、函数适配器 包含头文件functional （1）普通函数绑定 （2）类内成员函数绑定 （3）占位符表示原来的参数去第几位 五、函数包装器 包含头文件functional （1）包装普通函数 （2）包装成员函数和静态函数 (3)包装仿函数 ...
迭代器的两种写法
weixin_49054155的博客
07-21 764
import java.util.ArrayList; import java.util.Iterator; import java.util.List; //迭代器的两种方法 public class test { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("张三"); list.add("李四"); list.add
STL六大组件之迭代器（Iterator）
qq_57198230的博客
09-02 310
在STL的设计理念中，将存储数据的类型（容器）和操作容器的动作（算法）二者彼此独立开来，这就导致我们无法直接通过算法来去操作存储在容器中的数据，而Iteratror的设计，就是为了提供一种统一的访问容器中元素的方式，无论容器的内部结构如何，通过迭代器，我们的算法就能够去操作相应的数据。以标准库find（）为例，我们只需要告诉find查找元素的起始位置和终点位置，以及一个目标值，而不需要告诉它容器的类型，它就可以帮我们在该范围内找是否有目标值。
C++ 中迭代器的使用
qq_42244167的博客
10-23 206
在C++中，"iter"通常是一个缩写，代表迭代器（iterator），用于遍历容器类（如数组、列表、向量等）中的元素。迭代器允许你按顺序访问容器中的元素，而无需了解底层容器的实现细节。迭代器是C++中用于访问容器元素的重要工具，使你能够以一种通用的方式遍历不同类型的容器。在实际编程中，你可以根据需要选择使用不同类型的迭代器，以便更好地管理容器中的数据。成员函数来获取容器的开始和结束迭代器。然后，我们使用迭代器来遍历容器并打印出元素的值。范围循环自动选择合适的迭代器类型，并提供了更简单的语法。
C++迭代器（iterator）
热门推荐
weixin_47700137的博客
07-30 4万+
什么是迭代器 迭代器是一种可以遍历容器元素的数据类型。迭代器是一个变量，相当于容器和操纵容器的算法之间的中介。C++更趋向于使用迭代器而不是数组下标操作，因为标准库为每一种标准容器（如vector、map和list等）定义了一种迭代器类型，而只有少数容器（如vector）支持数组下标操作访问容器元素。可以通过迭代器指向你想访问容器的元素地址，通过*x打印出元素值。这和我们所熟知的指针极其类似。 C语言有指针，指针用起来十分灵活高效。 C++语言有迭代器，迭代器相对于指针而言功能更为丰富。 vector，是数
C++ iterator
#+!
02-05 2264
迭代器(iterator)是一中检查容器内元素并遍历元素的数据类型。 (1) 每种容器类型都定义了自己的迭代器类型，如vector: vector::iterator iter;这条语句定义了一个名为iter的变量，它的数据类型是由vector定义的iterator类型。 (2) 使用迭代器读取vector中的每一个元素： vector ivec(10,1); for(vector::i
iterator迭代器详解
06-09
在C++ STL中，迭代器被分为五类：输入迭代器、输出迭代器、正向迭代器、双向迭代器和随机访问迭代器。它们的特点和支持的操作不同，因此在使用迭代器时需要根据具体情况选择合适的迭代器类型。 总的来说，迭代器是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值