【C++】第八章 STL

该文章内容整理自《C++ Primer Plus（第6版）》、《Effective C++（第三版）》、以及网上各大博客

STL 是“Standard Template Library”的缩写，意为“标准模板库”，它是 C++ 标准库的一部分，借助模板把常用的数据结构及其算法都实现了一遍。STL 从广义上分为： 容器(container)、算法(algorithm)、以及迭代器(iterator)。容器和算法之间通过迭代器进行无缝连接

STL提供了六大组件，彼此之间可以组合套用

1. 容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据，从实现角度来看，STL容器是一种class template
2. 算法：各种常用的算法，如sort、find、copy、for_each。从实现的角度来看，STL算法是一种function template
3. 迭代器：扮演了容器与算法之间的胶合剂，共有五种类型，从实现角度来看，迭代器是一种将operator* 、operator-> 、operator++、operator–等指针相关操作予以重载的class template。所有STL容器都附带有自己专属的迭代器，只有容器的设计者才知道如何遍历自己的元素。原生指针(native pointer)也是一种迭代器
4. 仿函数：行为类似函数，可作为算法的某种策略。从实现角度来看，仿函数是一种重载了operator()的class 或者class template。仿函数可将对函数的修改都封装到类里面，通过类方法来进行

struct MyPlus{
    int operator()(const int &a , const int &b) const {
        return a + b;
    }
} a;

MyPlus()(1,2);	//通过产生临时对象调用重载运算符
a.operator()(1,2);	//通过对象显示调用重载运算符
a(1,2);		//通过对象类似函数调用 隐示地调用重载运算符

5. 适配器：一种用来修饰容器或者仿函数或迭代器接口的东西
6. 空间配置器：负责空间的配置与管理。从实现角度看，配置器是一个实现了动态空间配置、空间管理、空间释放的class tempalte
   STL六大组件的交互关系，容器通过空间配置器取得数据存储空间，算法通过迭代器存储容器中的内容，仿函数可以协助算法完成不同的策略的变化，适配器可以修饰仿函数

STL广义上的三大组件

1. 容器
   几乎任何特定的数据结构都是为了实现某种特定的算法。STL容器就是将运用最广泛的一些数据结构实现出来。常用的数据结构：数组(array)、链表(list)、tree(树)、栈(stack)、队列(queue)、集合(set)、映射表(map)，根据数据在容器中的排列特性，这些数据分为序列式容器和关联式容器两种
   (1). 序列式容器强调值的排序，序列式容器中的每个元素均有固定的位置，除非用删除或插入的操作改变这个位置。有Vector容器、Deque容器、List容器等
   (2). 关联式容器是非线性的树结构，更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系，也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。关联式容器另一个显著特点是在值中选择一个值作为关键字key，这个关键字对值起到索引的作用，方便查找。有Set容器、multiset容器、Map容器、multimap容器等
2. 算法
   算法是指问题的解法，以有限的步骤解决逻辑或数学上的问题。STL收录的算法经过了数学上的效能分析与证明，是极具复用价值的，包括常用的排序，查找等等。特定的算法往往搭配特定的数据结构，算法与数据结构相辅相成。算法可分为质变算法和非质变算法
   (1). 质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等
   (2). 非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等
3. 迭代器
   迭代器(iterator)是一种抽象的设计概念，现实程序语言中并没有直接对应于这个概念的实物。iterator模式定义如下：提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。迭代器的设计思维是STL的关键所在，STL的中心思想在于将容器(container)和算法(algorithms)分开，彼此独立设计，最后再一贴胶着剂将他们撮合在一起。从技术角度来看，容器和算法的泛型化并不困难，C++的class template和function template可分别达到目标，如果设计出两这个之间的良好的胶着剂，才是大难题。迭代器的种类如下
   

STL优点

• STL 是 C++的一部分，因此不用额外安装什么，它被内建在编译器之内
• STL 的一个重要特性是将数据和操作分离。数据由容器类别加以管理，操作则由可定制的算法定义。迭代器在两者之间充当“粘合剂”，以使算法可以和容器交互运作
• 程序员可以不用思考 STL 具体的实现过程，只要能够熟练使用 STL 就可以了
• STL 具有高可重用性，高性能，高移植性，跨平台的优点
  (1). 高可重用性：STL 中几乎所有的代码都采用了模板类和模版函数的方式实现，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会
  (2). 高性能：如 map 可以高效地从十万条记录里面查找出指定的记录，因为 map 是采用红黑树的变体实现的
  (3). 高移植性：如在项目 A 上用 STL 编写的模块，可以直接移植到项目 B 上

常见容器

string

C++98提供了string类，被包含在头文件string中。string类是STL中basic_string模板实例化得到的模板类。string 类的成员函数有很多，同一个名字的函数也常会有五六个重载的版本。这里仅对常用成员函数按功能进行分类并介绍。为方便起见，子串(n, m)是指从下标开始的m个字符组成的子串

1. 初始化
   string 类有多个构造函数，用法示例如下。另外，string类同样可以使用列表初始化

string s1();  		// s1 = ""
string s2("Hello"); // s2 = "Hello"
string s3(4, 'K');  // s3 = "KKKK"
string s4("12345", 1, 3);  //s4 = "234"，即 "12345" 的从下标1开始，长度为3的子串

//string类不能用整数或字符作为参数，下面两种方法错误
string s5('K');
string s6(123);

2. 赋值
   可以用字符串常量， char* 类型的变量、常量，以及 char 类型的变量、常量对 string 对象进行直接赋值。string 类还有 assign 成员函数，可以用来对 string 对象赋值。assign 成员函数返回对象自身的引用

string s1;
s1 = "Hello";  // s1 = "Hello"
s2 = 'K';  // s2 = "K”

string s1("12345"), s2;
s3.assign(s1);  // s3 = s1
s2.assign(s1, 1, 2);  // s2 = "23"，即 s1 的子串(1, 2)
s2.assign("abcde", 2, 3);  // s2 = "cde"
s2.assign(4, 'K');  // s2 = "KKKK"

3. 长度
   在string类中，length 成员函数与size 成员函数功能完全一样，都返回字符串的长度
4. 连接
   除了可以使用+和+=运算符对 string 对象执行字符串的连接操作外，string 类还有 append 成员函数，可以用来向字符串后面添加内容。append 成员函数返回对象自身的引用

string s1("123"), s2("abc");
s1.append(s2);  // s1 = "123abc"
s1.append(s2, 1, 2);  // s1 = "123abcbc"
s1.append("ABCDE", 2, 3);  // s1 = "123abcbcKKKCDE"
s1.append(3, 'K');  // s1 = "123abcbcKKK"

5. 比较
   除了可以用 <、<=、==、!=、>=、> 运算符比较 string 对象外，string 类还有 compare 成员函数，可用于比较字符串。另外，==操作符是重载调用了compare函数，因而两种方法结果一样，但是效率不同

string s1("hello"), s2("hello, world");
int n = s1.compare(s2);
n = s1.compare(1, 2, s2, 0, 3);  //比较s1的子串 (1,2) 和s2的子串 (0,3)
n = s1.compare(0, 2, s2);  // 比较s1的子串 (0,2) 和 s2
n = s1.compare("Hello");
n = s1.compare(1, 2, "Hello");  //比较 s1 的子串(1,2)和"Hello”
n = s1.compare(1, 2, "Hello", 1, 2);  //比较 s1 的子串(1,2)和 "Hello" 的子串(1,2)

6. 子串
   substr 成员函数可以用于求子串 (n, m)

string s1 = "this is ok";
string s2 = s1.substr(2, 4);  // s2 = "is i"
s2 = s1.substr(2);  // s2 = "is is ok"

7. 交换
   swap 成员函数可以交换两个 string 对象的内容

string s1("West”), s2("East");
s1.swap(s2);  // s1 = "East"，s2 = "West"

8. 查找
   string 类有一些查找子串和字符的成员函数，它们的返回值都是子串或字符在 string 对象字符串中的位置。如果查不到，则返回 string::npos。string::npos 是在 string 类中定义的一个静态常量。这些函数如下：
   find：从前往后查找子串或字符出现的位置
   rfind：从后往前查找子串或字符出现的位置
   find_first_of：从前往后查找何处出现另一个字符串中包含的字符
   find_last_of：从后往前查找何处出现另一个字符串中包含的字符
   find_first_not_of：从前往后查找何处出现另一个字符串中没有包含的字符
   find_last_not_of：从后往前查找何处出现另一个字符串中没有包含的字符

string s1("Source Code");
int n;
if((n = s1.find('u')) != string::npos)//查找 u 出现的位置
if((n = s1.find("Source", 3)) == string::npos)//从下标3开始查找 u 出现的位置
if((n = s1.find("Co")) != string::npos)//查找子串"Co"的位置
if((n = s1.find_first_of("ceo")) != string::npos)//查找第一次出现或 'c'、'e'或'o'的位置
if((n = s1.find_last_of('e')) != string::npos)//查找最后一个 'e' 的位置
if((n = s1.find_first_not_of("eou", 1)) != string::npos) //从下标1开始查找第一次出现非 'e'、'o' 或 'u' 字符的位置

9. 替换子串
   replace 成员函数可以对 string 对象中的子串进行替换，返回值为对象自身的引用

string s1("Real Steel");
s1.replace(1, 3, "123456", 2, 4);  //用 "123456" 的子串(2,4) 替换 s1 的子串(1,3)
s1.replace(2, 3, 5, '0');  //用 5 个 '0' 替换子串(2,3)
s1.replace(2, 5, "XXX");  //将子串(n,5)替换为"XXX"

10. 删除子串
    erase 成员函数可以删除 string 对象中的子串，返回值为对象自身的引用

string s1("Real Steel");
s1.erase(1, 3);  //删除子串(1, 3)，此后 s1 = "R Steel"
s1.erase(5);  //删除下标5及其后面的所有字符，此后 s1 = "R Ste"

11. 插入字符串
    insert 成员函数可以在 string 对象中插入另一个字符串，返回值为对象自身的引用

string s1("Limitless"), s2("00");
s1.insert(2, "123");  //在下标 2 处插入字符串"123"，s1 = "Li123mitless"
s1.insert(3, s2);  //在下标 2