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

最新推荐文章于 2025-10-03 10:32:55 发布
转载 最新推荐文章于 2025-10-03 10:32:55 发布 · 3.4w 阅读 · 140

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

容器：：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>
 
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

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>
 
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

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>
 
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

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>
 
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

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>
 
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

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>
 
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

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>
 
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

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>
 
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

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>
 
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

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>
 
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;
}

指针与数组
指针与其它数据结构呢？比如说链表？
存储空间是非连续的。不能通过对指向这种数据结构的指针做累加来遍历。
能不能提供一个行为类似指针的类，来对非数组的数据结构进行遍历呢？这样我们就能够以同样的方式来遍历所有数据结构（容器）。
迭代器(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>
 
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

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>
 
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

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>
 
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

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>
 
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

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>
 
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

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>
 
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

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>
 
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

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>
 
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

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>
 
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

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>
 
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;
}
STL 迭代器iteratior 详解
2301_79937517的博客
11-05 1335
介绍了C++中不同类型的迭代器的操作以及如何模拟实现一个自定义迭代器。通过理解STL中迭代器的工作原理，进一步帮助开发者掌握如何设计和使用迭代器以满足不同容器访问的需求。
C++ STL Iterator 迭代器
gopher9511的博客
08-16 867
TOCTOC。
STL迭代器简介
DoYou?'s csdn
07-03 4554
转自 http://www.cppblog.com/The-Moment/archive/2009/06/18/88023.html 标准模板库(The Standard Template Library, STL)定义了五种迭代器。下面的图表画出了这几种：            input         output              /            /       
C++：运算符重载
最新发布
2501_90377063的博客
10-03 996
取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，yi般这两个函数编译器自动生成的就可以够我们用了，不需要去显式实现。除非一些很特殊的场景，比如我们不想让别人取到当前类对象的地址，就可以自己实现⼀份，胡乱返回一个地址。，表明在const成员函数中不能对类的任何成员函数修改，如const修饰Date的Print，由Print(Date* const this)变为Print(const Date* const this)。const修饰成员函数，const放在成员函数参数列表后。
STL的用法详解和教程
01-23
ST STL的用法详解和教程L的用法 STL的用法详解和教程 STL的用法详解和教程
STL容器用法详解及注解(持续更新)
Cantredo
09-23 612
写在前面 以下摘录自wiki STL又称标准模板库，是一个c++软件库，其中包含4个组件，分别为： 算法 容器 函数 迭代器 STL将“在数据上的操作”与“要执行操作的数据分开”，分别以如下概念指代： 容器：包含、放置数据的地方。 迭代器： 在容器中指出一个位置、或成对使用以划定一个区域，用来限定操作所涉及到的数据范围。 算法： 要执行的操作。 总而言之，ST...
C++之STL迭代器
sinat_31608641的博客
11-22 1009
一、背景 迭代器(iterator)是一种抽象的设计理念，通过迭代器可以在不了解容器内部原理的情况下遍历容器。除此之外，STL中迭代器一个最重要的作用就是作为容器(vector,queue等)与STL算法的粘结剂，只要容器提供迭代器的接口，同一套算法代码可以利用在完全不同的容器中，这是抽象思想的经典应用。 以find函数为例 template <class _InputIter, class _Tp> inline _InputIter find(_InputIter __first,
C++：STL的六大组件详细介绍（配置器、容器、迭代器、算法、仿函数、适配器）
qq_42279379的博客
07-23 2690
C++：STL的六大组件详细介绍（配置器、容器、迭代器、算法、仿函数、适配器）
C++中STL各个迭代器详解
king_weng的博客
04-01 8713
1、自C++11起可以用range-based for循环来所有元素，但有时并不需要处理所有元素，此时可以使用迭代器。 std::vector<int> vec {1,2,3,4,5,6,7,8,9,10}; for (auto n : vec){ std::cout << n << endl; } 2、迭代器中用来表现容器中的某个位置 oper...
C++ STL入门：Iterator迭代器详解
"这篇教程主要介绍了STL中的Iterator（迭代器）及其在STL入门学习中的重要性。迭代器在STL中起着关键作用，它允许算法与容器分离发展，同时通过重载各种运算符使得操作复杂数据结构变得更加简便。通过迭代器，容器...
C++ STL ：迭代器
Sauron7i的博客
04-19 1153
文章目录迭代器1.迭代器的设计思维2.迭代器是一种smart pointer3.迭代器的五种相应型别3.1 value_type3.2 difference_type3.3 reference_type 迭代器 1.迭代器的设计思维 不论是泛型思维或STL的实际运用，迭代器（ iterators）都扮演着重要的角色。STL的中心思想在于：将数据容器( containers）和算法（ algorithms）分开，彼此独立设计，最后再以一帖胶着剂将它们撮合在一起。容器和算法的泛型化，从技术角度来看并不困难，C
STL用法详解
qq_40433783的博客
06-17 230
看博客： STL部分详解 String用法介绍 vector用法介绍
STL容器与迭代器
love10_1314的博客
08-20 347
C++提供了功能强大的标准模板库STL，STL的六大组件分别是容器、配接器、迭代器、泛型算法、仿函式、空间配置器。今天我们来看一下容器。 STL容器 STL容器分为三类，顺序容器、关联容器和容器适配器。 顺序容器有vector、list、deque。 vector是矢量容器，底层是一个动态开辟的一维数组，每次扩容为原来的2倍。 vector容器对象常用方法有push_back、pop_back、i...
STL 容器与迭代器
i_meteor_shower的博客
07-17 471
迭代器：迭代器是泛化的指针（但并不是指针），用法和指针类似，利用迭代器对容器中的元素序列的操作。格式举例list&lt;type&gt;::itrerator it; 迭代器本身是一个对象，这个对象可以遍历STL容器内部全部的对象，它能够反复地对STL容器内容进行访问。迭代器所提供的基本操作如下所示： a.获取当前被指向的元素，用“*” 或者“-&gt;” b.指向下一个元素，迭代器的增量使...
STL容器类和迭代器
习惯有你
12-18 381
STL容器类介绍 容器，顾名思义就是盛放东西的东西，如盛饭的饭碗就是一个容器，这样的容器c++库也为我们提供了，只是不能用来盛饭。在程序中只有数据和数据处理方法，数据和方法结合在一起就形成了类或对象，在面向对象的语言中流行一切皆是对象，要有对象首先肯定要有类，用来存放对象的类就叫容器类，简称容器。 计算机的运行时数据只能存放在内存中，而容器类就是用做容器的内存管理方法。容器的内涵就是数据结构（数据打包的方法）+算法（数据处理方法）。 容器其实我们早就接触...
STL的容器类和迭代器
weixin_44705391的博客
05-19 424
1.STL的容器类介绍 1.1、何为容器 (1)顾名思义，容器就是盛放东西的东西，这里被盛放的一般是数据对象，用来盛放的是容器类 (2)计算机中一切皆是数据，数据存储只能在内存中，而容器类是用做容器的内存的管理方法 (3)容器类的内核就是：数据结构 + 算法 (4)C语言语法内置的数组和结构体，就是语言源生支持的容器 (5)C++容器通过类库方式提供，容器类库被模板技术泛化后，就是STL容器了 1.2、STL有哪些容器类 (1)序列容器。元素在容器中的位置同元素的值无关，即容器不是排序的（类似于C数组）。包
C++STL：容器与迭代器
crossoverpptx的博客
07-07 1029
简单的理解容器，它就是一些模板类的集合，但和普通模板类不同的是，容器中封装的是组织数据的方法（也就是数据结构）。STL 提供有 3 类标准容器，分别是顺序容器、排序容器和哈希容器，其中后两类容器有时也统称为关联容器。
浅析STL三大组件，容器 算法 迭代器。
qq_51004011的博客
07-27 1158
迭代器是容器与算法之间的胶合剂，所有STL容器都附带有自己专属的迭代器，只有容器的设计者才知道如何遍历自己的元素。所以说，我们想遍历某一个容器，就必须使用这个容器的迭代器才可以。...
STL容器和迭代器用法归纳（1）
双脚踏实地
12-23 1218
           在我所看到的介绍STL的几本书和文章里。开头总要说STL能节省大量的时间和精力，但很多C++程序员确不知道，不会用，或不愿意用，因为觉得STL不好理解，不好用，复杂。可能也正如这些书中所说，我也经历过从不用到用的过程，而我身边也有人还没有使用STL。但其实只要我们需要存储信息，然后查询这些信息并使用，而且需要有一定形式的存储，并需要一定形式的获取这些存储的信息时，STL还
C++ STL迭代器详解：类型与操作
在C++编程中，STL（Standard Template Library，标准模板库）是其强大功能的重要组成部分，它提供了各种容器（如vector、list、set等）以及算法和迭代器等工具。迭代器是STL中用于遍历和访问容器中元素的关键概念，...
评论 5
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值