第11单元 标准模板库介绍

注：本部分内容主要来自中国大学MOOC北京邮电大学崔毅东的 《C++程序设计》课程。
注：94条 C++程序规范。

---

单元导读

  本单元重点是对标准模板库中的顺序容器、关联容器的使用，以及如何创建迭代器以遍历容器。在使用容器时要注意不同容器的实现方式对遍历、搜索、删除、插入容器元素的影响。此外还要注意，如果创建针对一个容器的迭代器后，又向容器插入或者删除了元素，那么大部分情况下，这个已经创建的迭代器是会失效的。很多同学在遍历容器时遇到这个问题而不知道原因，花费了大量的时间调试代码。

11.1 标准模板库(STL)基础

  本节来介绍C++标准模板库(Standard Template Library, STL)，STL并不是随着C++的诞生而来，而是由STL之父Stepanov(合作者Meng Lee)于上世纪八十年代末九十年代初创造，并于1994年2月正式成为ANSI/ISO C++的一部分(有修改)。但是要注意STL并不是“C++标准库(C++ Standard Library)”，STL只是C++标准库中重要的一部分，使用STL可以极大地简化编程语句。顾名思义STL使用了大量的模板，其由五部分组成：容器(Containers)、迭代器(Iterators)、 算法(Algorithms)、函数对象(Function Objects)、空间分配器(Memory Allocation)，下面简要的介绍前三个组件。

• 参考stackoverflow文章：“STL”和“C++标准库”的区别？

1. 容器(Containers)
  容器类似于“储物柜”，用于保存一组任意类型的数据，数据个体被称为“元素”。“容器”分为三类：

1. 顺序容器(Sequence containers)：是一种多个元素的有序集合的线性数据结构，有头有尾、有前有后，例如向量类vector、列表list、双端队列deque(double end queue)。
2. 关联容器(Associative containers)：是一种可快速定位元素的非线性数据结构，这类容器主要用于存储“键值对”，例如集合set、multiset、映射map、multimap。
3. 容器适配器(Container adapters)：并不是一个完整的容器，而是依赖于前面已有的容器进行构建，是顺序容器的受限版本，所以也被称为“二级容器”。主要用于处理特殊情况，例如栈stack、队列queue、优先队列priority_queue。

上表中：

1. vector：“快速”指的是执行效率。
2. deque：看起来功能比vector强，但实现时的开销比vector略微大一些，所以尽量使用vector。
3. list：不能直接访问任意元素，因为是使用“链表”这种数据结构实现。

2. 迭代器(Iterators)
  迭代器用于访问(遍历)容器中的元素，主要是解引用*、->、++等指针相关操作进行重载的类模板，比如for(int i=0; i<10; i++)中的i就可以看成是一个类似指针的东西，也就是迭代器。每个容器都有自己专属的迭代器，只有容器才知道如何遍历自己的元素。

  那迭代器作为一种泛型指针，不仅可以通过[]访问元素，还可以通过自增运算++指向下一个元素。一般情况下，迭代器不会单独使用，而是与容器共同使用，但总有一小部分例外：有些迭代器与容器无关，如istream iterator、ostream iterator。

• 11.4节、11.5节将演示如何使用迭代器遍历顺序容器、关联容器。

3. 算法(Algorithms)

  算法(algorithms)就是操作容器中数据的方法，并且在术语上“算法”经常可以和操作(operations)、函数(functions)、方法(methods)相替换。STL中提供了大约80种独立于容器的算法：查找、排序、比较、替换……可自行查找相关书籍。

11.2 STL容器简介

  上一节对于“容器”做出了简单的介绍，本小节就来介绍STL容器中一些通用的操作方法。下表11-2、表11-3给出了容器中一些常见的操作：

最后使用代码简单展示一下容器类的创建和操作，基本思路就是“创建容器类对象–>存入数据–>显示元素数量–>比较两个容器对象大小”：
源文件SimpleSTLDemo.cpp

#include <iostream>
#include <vector>
#include <list>
#include <deque>
#include <set>
#include <stack>
#include <queue>
using std::cout;
using std::endl;
int main() {//创建容器对象std::vector<int>     vector1,    vector2;std::list<int>       list1,      list2;std::deque<int>      deque1,     deque2;std::set<int>        set1,       set2;std::multiset<int>   multiset1,  multiset2;std::stack<int>      stack1,     stack2;std::queue<int>      queue1,     queue2;//测试方法：存入数据、显示元素数量、比较两个容器对象大小。//针对vector的测试代码cout << "针对vector的测试" << endl;vector1.push_back(1);   //存入1vector1.push_back(2);   //存入2vector2.push_back(30);  //存入30cout << "vector1当前元素数量：" << vector1.size() << endl;cout << "vector2当前元素数量：" << vector2.size() << endl;cout << "vector1最大容量：" << vector1.max_size() << endl;cout << "vector2最大容量：" << vector2.max_size() << endl;vector1.swap(vector2);//交换元素cout << "vector1当前元素数量：" << vector1.size() << endl;cout << "vector2当前元素数量：" << vector2.size() << endl;cout << "vector1 < vector2 : " << std::boolalpha << (vector1 < vector2) << endl << endl;//针对list的测试代码cout << "针对list的测试" << endl;list1.push_back(1);   //存入1list1.push_back(2);   //存入2list2.push_back(30);  //存入30cout << "list1当前元素数量：" << list1.size() << endl;cout << "list2当前元素数量：" << list2.size() << endl;cout << "list1最大容量：" << list1.max_size() << endl;cout << "list2最大容量：" << list2.max_size() << endl;list1.swap(list2);//交换元素cout << "list1当前元素数量：" << list1.size() << endl;cout << "list2当前元素数量：" << list2.size() << endl;cout << "list1 < list2 : " << std::boolalpha << (list1 < list2) << endl << endl;//针对deque的测试代码cout << "针对deque的测试" << endl;deque1.push_back(1);   //存入1deque1.push_back(2);   //存入2deque2.push_back(30);  //存入30cout << "deque1当前元素数量：" << deque1.size() << endl;cout << "deque2当前元素数量：" << deque2.size() << endl;cout << "deque1最大容量：" << deque1.max_size() << endl;cout << "deque2最大容量：" << deque2.max_size() << endl;deque1.swap(deque2);//交换元素cout << "deque1当前元素数量：" << deque1.size() << endl;cout << "deque2当前元素数量：" << deque2.size() << endl;cout << "deque1 < deque2 : " << std::boolalpha << (deque1 < deque2) << endl << endl;//针对set的测试代码cout << "针对set的测试" << endl;set1.insert(1);   //存入1set1.insert(1);   //存入1set1.insert(2);   //存入2set2.insert(30);  //存入30cout << "set1当前元素数量：" << set1.size() << endl;cout << "set2当前元素数量：" << set2.size() << endl;cout << "set1最大容量：" << set1.max_size() << endl;cout << "set2最大容量：" << set2.max_size() << endl;set1.swap(set2);//交换元素cout << "set1当前元素数量：" << set1.size() << endl;cout << "set2当前元素数量：" << set2.size() << endl;cout << "set1 < set2 : " << std::boolalpha << (set1 < set2) << endl << endl;//针对multiset的测试代码cout << "针对multiset的测试" << endl;multiset1.insert(1);   //存入1multiset1.insert(1);   //存入1multiset1.insert(2);   //存入2multiset2.insert(30);  //存入30cout << "multiset1当前元素数量：" << multiset1.size() << endl;cout << "multiset2当前元素数量：" << multiset2.size() << endl;cout << "multiset1最大容量：" << multiset1.max_size() << endl;cout << "multiset2最大容量：" << multiset2.max_size() << endl;multiset1.swap(multiset2);//交换元素cout << "multiset1当前元素数量：" << multiset1.size() << endl;cout << "multiset2当前元素数量：" << multiset2.size() << endl;cout << "multiset1 < multiset2 : " << std::boolalpha << (multiset1 < multiset2) << endl << endl;//下面是容器适配器的测试//针对stack的测试代码cout << "针对stack的测试" << endl;stack1.push(1);   //压入1stack1.push(1);   //压入1stack1.push(2);   //压入2stack2.push(30);  //压入30cout << "stack1当前元素数量：" << stack1.size() << endl;cout << "stack2当前元素数量：" << stack2.size() << endl;cout << "stack1 < stack2 : " << std::boolalpha << (stack1 < stack2) << endl << endl;//针对queue的测试代码cout << "针对queue的测试" << endl;queue1.push(1);   //存入1queue1.push(1);   //存入1queue1.push(2);   //存入2queue2.push(30);  //存入30cout << "queue1当前元素数量：" << queue1.size() << endl;cout << "queue2当前元素数量：" << queue2.size() << endl;cout << "queue1 < queue2 : " << std::boolalpha << (queue1 < queue2) << endl << endl;return 0;
}

运行结果：

针对vector的测试
vector1当前元素数量：2
vector2当前元素数量：1
vector1最大容量：1073741823
vector2最大容量：1073741823
vector1当前元素数量：1
vector2当前元素数量：2
vector1 < vector2 : false针对list的测试
list1当前元素数量：2
list2当前元素数量：1
list1最大容量：357913941
list2最大容量：357913941
list1当前元素数量：1
list2当前元素数量：2
list1 < list2 : false针对deque的测试
deque1当前元素数量：2
deque2当前元素数量：1
deque1最大容量：1073741823
deque2最大容量：1073741823
deque1当前元素数量：1
deque2当前元素数量：2
deque1 < deque2 : false针对set的测试
set1当前元素数量：2
set2当前元素数量：1
set1最大容量：214748364
set2最大容量：214748364
set1当前元素数量：1
set2当前元素数量：2
set1 < set2 : false针对multiset的测试
multiset1当前元素数量：3
multiset2当前元素数量：1
multiset1最大容量：214748364
multiset2最大容量：214748364
multiset1当前元素数量：1
multiset2当前元素数量：3
multiset1 < multiset2 : false针对stack的测试
stack1当前元素数量：3
stack2当前元素数量：1
stack1 < stack2 : true针对queue的测试
queue1当前元素数量：3
queue2当前元素数量：1
queue1 < queue2 : true

11.3 STL迭代器简介

11.3.1 使用迭代器访问容器中的元素

  迭代器的主要用途是访问和处理一级容器（顺序容器+关联容器）中的元素，并且一级容器中的某些函数也与迭代器有关，比如begin()返回首元素的指针、end()返回尾元素后面一个位置的指针。下面使用一段代码展示如何使用迭代器访问容器中的元素，并根据运行结果讨论不同容器对于元素的输入输出次序的影响：
源文件IteratorDemo.cpp：

#include <iostream>
#include <vector>
#include <set>
using std::cout;
using std::endl;
int main() {//创建vector对象并存入一些数据std::vector<int> intVector;intVector.push_back(10);intVector.push_back(40);intVector.push_back(50);intVector.push_back(20);intVector.push_back(30);//创建vector迭代器对象，并遍历vector所有元素std::vector<int>::iterator p1;cout << "遍历vector元素：";for (p1 = intVector.begin(); p1 != intVector.end(); p1++) {cout << *p1 << " ";}//创建set对象并存入一些数据std::set<int> intSet;intSet.insert(10);intSet.insert(40);intSet.insert(50);intSet.insert(20);intSet.insert(30);//创建set迭代器对象，并遍历set所有元素std::set<int>::iterator p2;cout << "\n遍历set元素：";for (p2 = intSet.begin(); p2 != intSet.end(); p2++) {cout << *p2 << " ";}return 0;
}

运行结果：

遍历vector元素：10 40 50 20 30
遍历set元素：10 20 30 40 50

编程感想：

1. 迭代器终止条件：注意在for循环中遍历迭代器时，因为迭代器类型是指针所以不能用小于<，而是只能用!=来判断迭代器何时到达末尾。
2. set存放次序：set中存放的值称为“键(key)”，其会按照一定的顺序将输入数据进行排序。所以set是关联容器，而vector是顺序容器。

11.3.2 迭代器类型

  本小节来讨论一下迭代器类型，每种容器都有自己的迭代器类型，如上图一般可分为5类。上面两个是根据迭代器只读/只写的内容来进行分类的；下面三个则是按照迭代器的变化方式来进行分类的：

1. 输入迭代器(Input iterators)：可读取所指内容(易混淆)。
2. 输出迭代器(Output iterators)：可修改所指内容(易混淆)。
3. 前向迭代器(Forward iterators)：只能单步向前移动。同时包含了输入迭代器、输出迭代器的功能，但是“虚线”表示前向迭代器不见得能完成输出迭代器的所有功能。
4. 双向迭代器(Bidirectional iterators)：只能单步前后移动。
5. 随机访问迭代器(Random access iterators)：类似普通指针可相加相减、任意跳转，功能最强大。

下面给出容器支持的迭代器类型：

11.3.3 迭代器支持的运算符操作

  那上一小节介绍了迭代器的不同类型，主要关注一级容器所包括的“随机访问迭代器”和“双向迭代器”，本小节就给出不同的迭代器都支持哪些运算符操作。下面给出了表11-5及迭代器的代码示例，注意关注代码中的p1都表现出了哪些类型的迭代器特征：

源文件IteratorOperatorDemo.cpp

#include <iostream>
#include <vector>
using std::cout;
using std::endl;
int main() {std::vector<int> intVector;intVector.push_back(10);intVector.push_back(20);intVector.push_back(30);intVector.push_back(40);intVector.push_back(50);intVector.push_back(60);//遍历所有vector对象，并将迭代器指向.end()std::vector<int>::iterator p1 = intVector.begin();cout << "intVector: ";for (; p1 != intVector.end(); p1++) {cout << *p1 << " ";}//迭代器运算符操作cout << endl << "intVector[5]: " << *(--p1) << endl;cout << "intVector[2]: " << *(p1 - 3) << endl;cout << "intVector[2]: " << p1[-3] << endl;*p1 = 1234;cout << "intVector[5]: " << *p1 << endl;return 0;
}

运行结果：

intVector: 10 20 30 40 50 60
intVector[5]: 60
intVector[2]: 30
intVector[2]: 30
intVector[5]: 1234

11.4 顺序容器

11.4.1 顺序容器的逻辑结构

  本小节介绍顺序容器的逻辑结构。顺序容器主要包含三个容器：随机访问迭代器std::vector、std::deque，以及双向迭代器std::list。下面来看一下这三个容器的一般特征：

1. std::vector相当于从一端操作的数组，当数组容量满了之后，就会申请新的更大空间，并将原有内容拷贝到这个新的空间之中。
2. std::deque则是双端队列，会不断地向两端增加数据，存满了就申请新的空间。
3. std::list是使用链表来实现的，“链表”可以简单的看成一些节点的链接，每个节点都包含两个指针，分别指向其前面和后面的元素，所以每个节点都有前驱和后继。list也是可以在两端进行操作的，并且由于使用链表实现，所以在list中放入和删除元素，其速度和效率都比vector和deque要快。

11.4.2 代码展示std::vector

下面来看一下std::vector容器的代码示例：
源文件VectorDemo.cpp：

#include <iostream>
#include <vector>
using std::cout;
using std::endl;
int main() {double values[] = { 1,2,3,4,5,6,7 };//构造向量，用迭代器[begin, end)间的元素初始化向量std::vector<double> doubleVector(values, values + 7);//数组的名字就是指针cout << "1. doubleVector的初始内容：";for (int i = 0; i < doubleVector.size(); i++) {cout << doubleVector[i] << " ";}//顺序容器通用函数：assign(n, elem)将n份元素拷贝赋值给容器doubleVector.assign(4, 11.5);cout << "\n2. assign后，doubleVector的内容：";for (int i = 0; i < doubleVector.size(); i++) {cout << doubleVector[i] << " ";}//vector/deque特有函数：at(index)返回指定位置的元素doubleVector.at(0) = 22.4;cout << "\n3. at后，doubleVector的内容：";for (int i = 0; i < doubleVector.size(); i++) {cout << doubleVector[i] << " ";}//顺序容器通用函数：insert(position, elem)将元素插入指定位置std::vector<double>::iterator itr = doubleVector.begin();//定义迭代器，令其指向向量首位置doubleVector.insert(itr + 1, 555);//！警告！调用vector的insert之后，所有的迭代器都【可能】会失效itr = doubleVector.begin();//保险起见，重新定义迭代器doubleVector.insert(itr + 1, 666);cout << "\n4. insert后，doubleVector的内容：";for (int i = 0; i < doubleVector.size(); i++) {cout << doubleVector[i] << " ";}//一级容器通用函数：erase(beg, end)删除[beg,end)范围的元素doubleVector.erase(itr + 2, itr + 4);//！警告！调用vector的erase之后，beg及之后所有的迭代器都【可能】会失效cout << "\n5. erase后，doubleVector的内容：";for (int i = 0; i < doubleVector.size(); i++) {cout << doubleVector[i] << " ";}//一级容器通用函数：clear()删除所有元素doubleVector.clear();cout << "\n6. doubleVector现有数据数量：" << doubleVector.size() << endl;cout << "   doubleVector空了吗？" << std::boolalpha << doubleVector.empty() << endl;return 0;
}

运行结果：

1. doubleVector的初始内容：1 2 3 4 5 6 7
2. assign后，doubleVector的内容：11.5 11.5 11.5 11.5
3. at后，doubleVector的内容：22.4 11.5 11.5 11.5
4. insert后，doubleVector的内容：22.4 666 555 11.5 11.5 11.5
5. erase后，doubleVector的内容：22.4 666 11.5 11.5
6. doubleVector现有数据数量：0doubleVector空了吗？true

11.4.3 代码展示std::deque

下面来看一下std::deque容器的代码示例：
源文件DequeDemo.cpp：

#include <iostream>
#include <deque>
using std::cout;
using std::endl;
//该模板用于输出deque中的所有元素
template <typename T=double>
void deque_print(std::deque<T>& deque1) {for (int i = 0; i < deque1.size(); i++) {cout << deque1[i] << " ";}
}
int main() {double values[] = { 1,2,3,4,5,6,7 };//构造deque，用迭代器[begin, end)间的元素初始化向量std::deque<double> doubleDeque(values, values + 7);//数组的名字就是指针cout << "1. doubleDeque的初始内容：";deque_print(doubleDeque);//顺序容器通用函数：assign(n, elem)将n份元素拷贝赋值给容器doubleDeque.assign(4, 11.5);cout << "\n2. assign后，doubleDeque的内容：";deque_print(doubleDeque);//vector/deque特有函数：at(index)返回指定位置的元素doubleDeque.at(0) = 22.4;cout << "\n3. at后，doubleDeque的内容：";deque_print(doubleDeque);//顺序容器通用函数：insert(position, elem)将元素插入指定位置std::deque<double>::iterator itr = doubleDeque.begin();//定义迭代器，令其指向向量首位置doubleDeque.insert(itr + 1, 555);//！警告！调用deque的insert之后，所有的迭代器都【必然】失效！itr = doubleDeque.begin();//保险起见，重新定义迭代器doubleDeque.insert(itr + 1, 666);itr = doubleDeque.begin();//保险起见，重新定义迭代器cout << "\n4. insert后，doubleDeque的内容：";deque_print(doubleDeque);//一级容器通用函数：erase(beg, end)删除[beg,end)范围的元素doubleDeque.erase(itr + 2, itr + 4);//！警告！调用deque的erase之后，beg及之后所有的迭代器都【可能】失效！cout << "\n5. erase后，doubleDeque的内容：";deque_print(doubleDeque);//一级容器通用函数：clear()删除所有元素doubleDeque.clear();cout << "\n6. doubleDeque现有数据数量：" << doubleDeque.size() << endl;cout << "   doubleDeque空了吗？" << std::boolalpha << doubleDeque.empty();//deque/list特有函数：push_front()将元素压入队头doubleDeque.push_front(10.10);doubleDeque.push_front(20.22);doubleDeque.push_front(30.33);cout << "\n7. push_front后，doubleDeque的内容：";deque_print(doubleDeque);//deque/list特有函数：pop_front()删除队首元素doubleDeque.pop_front();//顺序容器通用函数：pop_back()删除容器尾元素doubleDeque.pop_back();cout << "\n8. pop_front/back后，doubleDeque的内容：";deque_print(doubleDeque);return 0;
}

运行结果：

1. doubleDeque的初始内容：1 2 3 4 5 6 7
2. assign后，doubleDeque的内容：11.5 11.5 11.5 11.5
3. at后，doubleDeque的内容：22.4 11.5 11.5 11.5
4. insert后，doubleDeque的内容：22.4 666 555 11.5 11.5 11.5
5. erase后，doubleDeque的内容：22.4 666 11.5 11.5
6. doubleDeque现有数据数量：0doubleDeque空了吗？true
7. push_front后，doubleDeque的内容：30.33 20.22 10.1
8. pop_front/back后，doubleDeque的内容：20.22

11.4.4 代码展示std::list

下面来看一下std::list容器的代码示例：
源文件ListDemo.cpp：

#include <iostream>
#include <list>
using std::cout;
using std::endl;
template <typename T = int>
void list_print(std::list<T>& list1) {typename std::list<T>::iterator p;//list的迭代器是双向迭代器for (p = list1.begin(); p != list1.end(); p++) {cout << *p << " ";}
}
int main() {int values[] = { 1,2,3,4,5,6,7 };//构造list，用迭代器[begin, end)间的元素初始化向量std::list<int> intList(values, values + 7);//数组的名字就是指针cout << "1. intList的初始内容：";std::list<int>::iterator p;//list的迭代器是双向迭代器，不支持随机访问，只能双向访问for (p = intList.begin(); p != intList.end(); p++) {cout << *p << " ";}//顺序容器通用函数：assign(n, elem)将n份元素拷贝赋值给容器intList.assign(4, 11);cout << "\n2. assign后，intList的内容：";list_print(intList);//顺序容器通用函数：insert(position, elem)将元素插入指定位置std::list<int>::iterator itr = intList.begin();itr++;//迭代器指向第2个11：11 ^11 11 11intList.insert(itr, 555);//11 555 ^11 11 11//！重要！调用list的insert之后，迭代器不受影响！仍然指向第二个11！!intList.insert(itr, 666);//11 555 666 ^11 11 11cout << "\n3. insert后，intList的内容：";list_print(intList);//一级容器通用函数：erase(beg, end)删除[beg,end)范围的元素std::list<int>::iterator beg = intList.begin();itr++;                  //11 555 666 11 ^11 11intList.erase(beg, itr);//11 11//！警告！调用list的erase之后，被删除元素的迭代器失效，其它元素迭代器正常！cout << "\n4. erase后，intList的内容：";list_print(intList);//一级容器通用函数：clear()删除所有元素intList.clear();cout << "\n5. intList现有数据数量：" << intList.size() << endl;cout << "   intList为空？" << std::boolalpha << intList.empty();//deque/list特有函数：push_front()将元素压入队头intList.push_front(10);intList.push_front(11);intList.push_front(12);cout << "\n6. push_front后，intList的内容：";list_print(intList);// 12 11 10//deque/list特有函数：pop_front()删除队首元素intList.pop_front();//顺序容器通用函数：pop_back()删除容器尾元素intList.pop_back();cout << "\n7. pop_front/back后，intList的内容：";list_print(intList);//11//list特有函数：sort()将元素按升序排序int values1[] = { 7,3,2,1 };intList.assign(values1, values1 + 4);intList.sort();cout << "\n8. sort后，intList的内容：";list_print(intList);//list特有函数：list1.merge(list2)将排好序的list2添加到list1中，并清空list2，//合并后的list1也是排好序的。std::list<int> intList2(intList);//std::list<int> intList2({1,4,5,6});//1 1 2 3 4 5 6 7intList.merge(intList2);//1 1 2 2 3 3 7 7cout << "\n9. merge后，intList的内容：";list_print(intList);cout << "\n   intList2为空？" << intList2.empty();//list特有函数：reverse()反转本列表intList.reverse();//7 7 3 3 2 2 1 1cout << "\n10. reverse后，intList的内容：";list_print(intList);intList.push_back(7);intList.push_back(1);//7 7 3 3 2 2 1 1 7 1//list特有函数：remove(elem)删除表中与elem相等的元素intList.remove(7);//3 3 2 2 1 1 1cout << "\n11. remove后，intList的内容：";list_print(intList);//list特有函数：splice(pos,lis)将lis中所有元素移至本表pos位置，并清空lisintList2.assign(7, 2);//2 2 2 2 2 2 2cout << "\n12. splice前，intList2的内容：";list_print(intList2);p = intList2.begin();intList2.splice(p, intList);//cout << "\n    splice后，intList2的内容：";list_print(intList2);cout << "\n    intList为空？" << intList.empty();return 0;
}

运行结果：

1. intList的初始内容：1 2 3 4 5 6 7
2. assign后，intList的内容：11 11 11 11
3. insert后，intList的内容：11 555 666 11 11 11
4. erase后，intList的内容：11 11
5. intList现有数据数量：0intList为空？true
6. push_front后，intList的内容：12 11 10
7. pop_front/back后，intList的内容：11
8. sort后，intList的内容：1 2 3 7
9. merge后，intList的内容：1 1 2 2 3 3 7 7intList2为空？true
10. reverse后，intList的内容：7 7 3 3 2 2 1 1
11. remove后，intList的内容：3 3 2 2 1 1 1
12. splice前，intList2的内容：2 2 2 2 2 2 2splice后，intList2的内容：3 3 2 2 1 1 1 2 2 2 2 2 2 2intList为空？true

编程感想：

1. 函数模板中的typename：本来想着写一个函数模板，方便打印整个std::list的内容。但由于思路是使用迭代器作为遍历元素，所以这个迭代器std::list<T>::iterator就是从属类型，其类型也是不确定的，就需要加上typename关键字变成：typename std::list<T>::iterator p;。具体可以见CSDN博文“C7510：类型从属名称的使用必须以“typename”为前缀”。

11.5 关联容器

11.5.1 关联容器的逻辑结构

  本小节介绍关联容器的逻辑结构。关联容器包含四个容器std::set、std::multiset、std::map、std::multimap，并且都只能使用双向迭代器进行访问。也就是说，关联容器仅支持通过对迭代器进行解引用，才能访问元素“key”。并且关联容器使用“key”快速存取元素，元素会按照一定的规则排序(默认升序排序)。下面介绍上图所示的结构说明：

1. std::set、std::multiset：存放的都是互相独立的“键”(key)，只是std::set中的值不能重复，std::multiset可以重复。
2. std::map、std::multimap：存放的都是互相独立的“键值对”(key value pair)。同样的，std::map中的键不能重复，但是键所对应的值无所谓；而std::multimap中的键可以重复。

11.5.2 代码展示std::multiset

下面来看一下std::multiset的代码示例：
源文件SetDemo.cpp：

#include <iostream>
#include <set>
using std::cout;
using std::endl;
//std::multiset函数模板：打印所有元素
template <typename T, typename Q>
void set_print(std::multiset<T, Q>& multiset1) {//多定义的Q是排序参数，主函数中不写也没事typename std::multiset<T>::iterator p = multiset1.begin();for (; p != multiset1.end(); p++) {cout << *p << " ";}
}int main() {int values[] = { 3,5,1,7,2,2 };//构造multiset，用迭代器[beg, end)间的元素初始化deque//升序排列 1,2,2,3,5,7std::multiset<int> multiset1(values, values + 6);//降序排序 7,5,3,2,2,1//std::multiset<int, std::greater<int> > set1(values, values + 6);cout << "1. set1的初始内容：";set_print(multiset1);//关联容器通用函数：insert(key)将元素按照一定规则插入multiset1.insert(555);   //1,2,2,3,5,7,555multiset1.insert(1);     //1,1,2,2,3,5,7,555cout << "\n2. insert后，multiset1的内容：";set_print(multiset1);//关联容器通用函数：lower_bound(key)返回指向第一个key元素的迭代器//                  upper_bound(key)返回指向最后一个key元素后一个的迭代器std::multiset<int>::iterator p;p = multiset1.lower_bound(2);//p指向容器中第一个2cout << "\n3. multiset1.lower_bound(2)输出：" << *p;p = multiset1.upper_bound(2);//p指向容器中最后一个2的后面一个cout << "\n   multiset1.upper_bound(2)输出：" << *p;//关联容器通用函数：find(key)返回指向第一个key元素的迭代器//                  count(key)返回容器中具有key的元素的数目p = multiset1.find(2);if (p == multiset1.end()) //若迭代器指向multiset1尾部，则未找到cout << "\n4. 当前集合没有“2”！";elsecout << "\n4. 当前集合中2的数量：" << multiset1.count(2);//一级容器通用函数：erase(beg, end)删除[beg,end)范围的元素//                  erase(key)删除集合中所有的key元素cout << "\n5. erase前，multiset1的内容：";set_print(multiset1);//multiset1.erase(p, multiset1.end());multiset1.erase(2);cout << "\n   erase后，multiset1的内容：";set_print(multiset1);return 0;
}

运行结果：

1. set1的初始内容：1 2 2 3 5 7
2. insert后，multiset1的内容：1 1 2 2 3 5 7 555
3. multiset1.lower_bound(2)输出：2multiset1.upper_bound(2)输出：3
4. 当前集合中2的数量：2
5. erase前，multiset1的内容：1 1 2 2 3 5 7 555erase后，multiset1的内容：1 1 3 5 7 555

11.5.3 代码展示std::map

下面来看一下std::map的代码示例：
源文件MapDemo.cpp：

#include <iostream>
#include <map>
#include <string>
using std::cout;
using std::endl;
//std::map函数模板：打印所有元素
template <typename T, typename Q>
void map_print(std::map<T, Q>& map1) {typename std::map<T, Q>::iterator p = map1.begin();for (; p != map1.end(); p++) {cout << p->first << " " << p->second << endl;//使用first访问key，使用second访问value}
}
int main() {//关联容器通用函数：insert(key, value)将元素按照一定规则插入std::map<int, std::string> map1;map1.insert(std::map<int, std::string>::value_type(101, "李四"));map1.insert(std::map<int, std::string>::value_type(100, "张三"));map1.insert(std::map<int, std::string>::value_type(103, "好美丽"));map1.insert(std::map<int, std::string>::value_type(102, "真潇洒"));cout << "1. map1的初始内容：\n";map_print(map1);//关联容器通用函数：find(key)返回指向第一个key元素的迭代器cout << "\n2. 请输入要寻找的key：";int key;std::cin >> key;std::map<int, std::string>::iterator p = map1.find(key);if (p == map1.end()) //若迭代器指向map1尾部，则未找到cout << "   key " << key << " 未找到！";elsecout << "   已找到键值对：" << p->first << " " << p->second << endl;//一级容器通用函数：erase(beg, end)删除[beg,end)范围的元素//                  erase(key)删除map中所有key对应的键值对cout << "\n3. erase前，map1的内容：\n";map_print(map1);//map1.erase(p, map1.end());map1.erase(103);cout << "   erase(103)后，map1的内容：\n";map_print(map1);return 0;
}

运行结果：

1. map1的初始内容：
100 张三
101 李四
102 真潇洒
103 好美丽2. 请输入要寻找的key：100已找到键值对：100 张三3. erase前，map1的内容：
100 张三
101 李四
102 真潇洒
103 好美丽erase(103)后，map1的内容：
100 张三
101 李四
102 真潇洒

11.6 容器适配器

  最后一小节来介绍容器适配器。但很可惜的老师并没有讲这一小节的内容，我也没有找到相关的代码文件StackDemo、QueueDemo，所以就将最后两页PPT放在这里，以后有空再补一下。