C++ STL 概述_严丝合缝的合作者们

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 旅行地图，然后再一一击破。