1. 初识 STL
什么是STL？
STL（Standard Template Library） 是C++以模板形式提供的一套标准库，提供了很多开发过程需要的通用功能模块。使用 STL ，可以让开发者将主要精力用于解决程序的高级业务逻辑，而无须关心底层的基础逻辑调用。
STL 由 6 大部分组成：
容器：存储和组织数据的类模板，是STL的核心。迭代器：独立于容器，提供访问容器中数据的通用操作组件。算法：提供通用基础算法功能，算法通过迭代器对容器中的数据进行查找、计算……。函数对象：重载了括号运算符（）的模板类，为算法提供灵活的策略。适配器：通过对已有的容器、迭代器、函数对象进行适配，创造出新的编程组件。配置器：为容器服务，负责其内存空间的配置与管理。
6大部件遵循单一职责设计思想，组件与组件之间彼此独立，每一个组件在各自内部高度自治性地实现分配到的功能。
各组件在合作关系上，互为依赖，相互之间形成服务与被服务关系。从而构建出一个精密、灵活、具有高度自适应的编程环境。
如下图为组件之间的分工合作关系：
学习STL包括：
- 了解、熟悉各组件的使用。
- 掌握各组件之间的服务关系。
因STL知识体系庞大而复杂，非一言二语能讲透。本文仅俯瞰一下STL，对STL有一个大概了解，对每一个组件的细节讨论将留到系列文章中讲解。
下面通过一个简单的案例初步了解容器、迭代器、算法、函数对象之间的合作关系。
案例需求：求解一个已知数列中的所有质数（质数：只能被 1 和自身整除的数字）。
设计流程：
- 首先在源代码文件的头部包含程序中需要用到的所有头文件。
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
- 认识
STL的vector容器，使用它存储已知数列。
STL中的容器种类繁多，容器之间有共性操作、也存在个体差异性，可适配于不同的应用场景。在常规操作时，可选择
vector容器，需要包含<vector>头文件。
vector<int> nums= {2,9,10,13,21,5};
- 认识
迭代器，遍历容器。迭代器类似于指针，用于访问容器。
//获取到指向容器第一个数据的迭代器
vector<int>::iterator begin=nums.begin();
//获取到指向器结束位置的迭代器，注意，并不是最后一个数据，而是最后一个数据的下一个存储位置
vector<int>::iterator end=nums.end();
//使用迭代器输出容器中数据
while(begin!=end){
cout<<*begin<<"\t";
begin++;
}
cout<<endl;
- 认识函数对象，使用函数对象编写求解质数的算法。函数对象可以为
STL的算法组件提供特定的算法策略，算法组件充当了平台功能，利用平台耦合容器、函数对象。类似于拼搭游戏，可以有各种可能。
下面代码用到了
sqrt函数，需要包含<cmath>头文件。
//使用结构体作为函数对象
template <typename T>
struct Zs {
// 函数对象的特点：重载 () 运算符
void operator()(T & x) const {
//求解质数的算法
bool isZs=true;
for(T i=2; i<=sqrt(x); i++) {
if (x % i==0) {
isZs=false;
break;
}
}
if(isZs)
cout<<x<<"是质数"<<endl;
}
};
- 使用
for_each算法 。STL提供了大量算法，使用时需要包含<algorithm>头文件。
//重新指向容器的开始位置（因为前面的操作移动过迭代器）
begin=nums.begin();
//使用 for_each 算法组件
for_each(begin,end,Zs<int>());
- 输出结果。
STL使用了高内聚、低耦合的设计理念，各组件的专业能力非常强，合作时又能做到严丝合缝、润物细无声。
容器专注于数据的存储。迭代器专注于容器的访问。函数对象提供具体的算法策略。算法相当于发动机，提供聚合动力。
容器是STL的核心(无数据无程序)组件，且类型繁多，下文将简要介绍容器的共性操作。
2. 容器
STL中的容器和数组相似，能够存储数据集，但有其自身的特点：
- 支持容量的自动增长。当添加数据时，如果容量不够时，容器会自动分配新的内存。
- 容器可以迭代。
- 支持数据类型参数(泛型编程)。
2.1 分类
STL中的容器众多，有点乱入花丛渐迷眼的既视感。一般会按照存储方式对其进行分类：
- 序列式容器：数据以添加时的顺序进行存储，当然可以对数据排序。
- 关联式容器：数据由
键和值两部分组成。
2.1.1 序列式容器
序列式容器的存储方案有 2 种：
- 连续（线性）存储：基于数组的存储方式，数据与数据在内存中是相邻的。
- 链式（非线性）存储：以节点的方式非线性存储。数据与数据在内存中并不一定相邻，结点之间通过存储彼此的地址知道对方的位置。
STL中常用到的序列式容器对象：
vector：向量，线性存储，类似于数组。需要包含<vector>头文件。list：双向链表，非线性存储。需要包含<list>头文件。slist：单向链表，非线性存储。需要包含<slit>头文件。deque：双向队列。需要包含<deque>头文件。- stack：栈，先进后出。需要包含
<stack>头文件。 queue：队列，数据先进先出。需要包含<queue>头文件。priority_queue：优先级队列。需要包含<queue>头文件。
2.1.2 关联式容器
关联式容器也有 2 种存储方案：
- 使用搜索二叉树：容器中的元素依照键值进行排序。
STL是用红黑树实现关联容器，红黑树是一种查找效率很高的平衡搜索二叉树。
- 使用哈希表：对键值进行哈希算法，然后根据哈希值把数据存储在不同的单元中。
STL中常用的关联容器：
set：集合。包含头文件<set>。map：映射。包含头文件<map>。multiset：可重复集合。包含头文件<set>。multimap：可重复映射。包含头文件<map>。
2.2 容器的通用操作
2.2.1 初始化
使用容器时包含：
-
创建容器。
-
初始化容器。初始化时可以指定容器的容量、为容器指定一系列初始值、为容器中的数据指定比较方法……
初始化序列化容器：
#include <iostream>
#include <vector>
#include <algorithm>
#include <list>
#include <set>
using namespace std;
//使用结构体作为函数对象
int main(int argc, char** argv) {
//初始容量为 12 向量容器
vector<int> vec(12);
cout<<"容器大小："<<vec.size()<<endl;
//初始化长度为 2，且值为 12 、30的向量容器
vector<int> vec1 {12,30};
cout<<"容器大小："<<vec1.size()<<endl;
//构造整型链表，初始容量 34
list<int> lst(34);
cout<<"容器大小："<<lst.size()<<endl;
//整型数组
int ary1[5]= {1,2,3,4,5};
//用数组初始化
vector<int> vec2(ary1,ary1+5);
cout<<"容器大小："<<vec2.size()<<endl;
//用向量初始化链表
list<int> intList(vec.begin(),vec.end());
cout<<"容器大小："<<intList.size()<<endl;
//用链表初始化集合
set<int> intSet(lst.begin(),lst.end());
cout<<"容器大小："<<intSet.size()<<endl;
return 0;
}
输出结果：
初始化map、set容器时。
//创建并初始化集合
set<int> mySet {1,5,3};
//构造 map 容器
map<std::string, int> myMap;
//构造并初始化
std::map<std::string, int>myMap{ {"rose",1},{"jone",2} };
//输出
for (auto iter = myMap.begin(); iter != myMap.end(); ++iter) {
cout << iter->first << " " << iter->second << endl;
}
输出结果：
jone 2
rose 1
2.2.2 添加数据
一般要求容器组件提供对数据进行常规维护的方法（增、删、改、查……）。
STL为 2类容器提供了insert方法，可以在指定的位置为容器加入新的数据。
这里需要注意：
STL位置一般用迭代器描述，而不是索引位置。
// 初始化向量
vector<int> vec {1, 2, 3, 4, 5};
//开始迭代器
vector<int>::iterator begin=vec.begin();
//结束迭代器
vector<int>::iterator end=vec.end();
cout<<"原向量容器数据"<<endl;
for(; begin!=end; begin++) {
cout<<*begin<<"\t";
}
//重置开始位置
begin=vec.begin();
// 指向容器vec的第三个元素
begin =begin + 2;
//在位置 3 插入数据
vec.insert( begin, 6 );
//重置开始和结束位置
begin=vec.begin();
end=vec.end();
cout<<"\n插入数据后："<<endl;
for(; begin!=end; begin++) {
cout<<*begin<<"\t";
}
输出结果：
关联式容器的插入数据效果和序列式容插入效果会有不同。
- 序列式容器中插入数据后，期望位置和最终结果位置是一样的。如期望插入在第
3个数据之后，实际也是插入在第3个数据之后。 - 关联式容器会自动按
键进行位置重排，会出现期望位置和最终位置不一样的情况（特别在以红黑树存储数据时，为了保持平衡性，会对数据进行平衡处理）。
STL还为序列式容器提供了push、push_back、push_front方法，此方法只能在容器头或容器尾进行数据添加。
// 声明一个向量
vector<int> vec(10);
// 压入数据
vec.push_back(1);
vec.push_back( 1 );
vec.push_back( 2 );
// 声明一个链表
list<int> ls(10);
// 压入数据
ls.push_back( 1 );
ls.push_front( 2 );
// 声明一个栈,栈只有 push 方法
stack<string> st;
// 压入数据
st.push("A");
2.2.3 删除数据
STL的容器都有 erase方法，用来删除指定位置或区间的数据。也提供有clear方法，用来清除整个容器。
位置和区间都需使用迭代器指定。
// 初始化向量
vector<int> vec {1, 2, 3, 4, 5, 6};
//指向容器vec的第三个元素
vector<int>::iterator iter = vec.begin() + 2;
// 删除第三个元素
vec.erase(iter);
//指向容器vec的第三个元素
iter = vec.begin() + 2;
// 删除第二个元素之后的所有元素
vec.erase(iter, vec.end() );
// 构造一个集合
set<int> intSet( ary1, ary1+5 );
// 删除键值为4的元素（集合的键值与实值是一致的）
intSet.erase( 4 );
2.2.4 查找数据
序列式容器没有提供查找方法，但是，如果某容器类重载了[]运算符，则可以通过给定数据的索引号找到相应数据，也可以通过 at方式进行查找。
// 初始化向量
vector<int> vec {1, 2, 3, 4, 5, 6};
int tmp= vec[2];
cout<<tmp<<endl;
//效果上面一样
tmp= vec.at(2);
cout<<tmp<<endl;
序列式容器一般都会提供front和back方法，用来返回第一个和最后一个数据。因为栈的特殊性，只有top方法用来返回栈顶数据。
vector<int> vec {1, 2, 3, 4, 5, 6};
list<int> intList( vec.begin(), vec.end() );
//返回第一个数据
x = intList.front();
//返回最后一个数据
x = intList.back();
stack<int,vector<int> > st;
//返回栈顶数据
x = st.top();
关联式容器提供有专门的find方法，可通过指定键值进行查找，注意，返回的是用迭代器所描述的位置。
// 整数型数组
int ary[5] = { 3, 1, 5, 2, 4};
// 构造集合
set<int> intSet( ary, ary+5 );
// 查找集合中键值为4的元素
set<int>::iterator iter = intSet.find( 4 );
//输出
cout<<*iter<<endl;
基于组件的分工合作设计思想，容器自身的查找只会提供一些基本功能。当有更复杂的查找需求时，可以使用STL算法中相应的函数模板进行查询，例如find，find_if，find_end和find_first_of。
2.2.5 修改数据
可以先查找到要修改的数据，然后直接修改，如果查找数据时返回的是迭代器，则可以通过迭代器进行修改。
// 构造向量
vector<int> vec { 3, 1, 5, 2, 4};
//直接修改
vec[3] =9;
//[] 反回的是向量数据的引用
int &refTmp=vec[3];
//和前面的直接修改一样
refTmp=9;
map<int,int> myMap();
//按键值查找，返回迭代器
map<int,int>::iterator iter=myMap.find(10);
//通过迭代器修改
iter->second=8;
//和上面的效果一样
myMap[10]=8;
2.2.6 其它方法
begin： 返回容器开始位置的迭代器。end：返回容器尾部数据后一个存储位置的迭代器。rbegin：求指向容器反向开始元素的迭代器。rend：求容器反向结尾元素后一个存储单元的迭代器。swap：交换两个容器的内容。swap方法用来交换两个容器的内容。要求两个容器的类型、大小相同。
//构造两个向量
vector<int> v1 {1, 2, 3};
vector<int> v2 {4, 5, 6};
//交换两个向量
v1.swap(v2);
vector<int>::iterator iter = v2.begin();
//输出向量v2的内容
for(; iter != v2.end(); iter++) {
cout<<*iter<<endl;
}
==、!=、<、<=、>、>=：比较运算符，判断两个容器之间的关系。比较返回结果是第一对不相等数据间的比较结果。如果两个容器的数据数目不相等，则容器不相等。
// 定义两个向量
vector <int> v1, v2;
// 在v1中加入数据
v1.push_back( 1 );
v1.push_back( 2 );
v1.push_back( 3 );
// 在v2中加入数据
v2.push_back( 1 );
v2.push_back( 3 );
//返回结果是 V1 第一个数据与 V2 中第一个数据的比较结果
bool res=v1 < v2;
// 输出1，true 如果 v1 的第一个数据是 4 则，输出 0
cout<< "v1 < v2：" <<res <<endl;
3. 总结
STL是一个庞大且功能非常完善的组件库，本文仅对其做了一个大概的描述，但是，一叶也能知秋，旨在理顺其脉络，先画出STL 旅行地图，然后再一一击破。