标准模板库（STL）一：基本概念

标准模板库 STL

概述

STL：standard template library

c++里的重用

• 面向对象：继承、多态、标准类库
• 泛型程序设计：模板机制，STL

泛型程序设计

将一些常用的数据结构（比如链表，数组，二叉树）和算法（比如排序，查找）写成模板，以后则不论数据结构里放的是什么对象，算法针对什么样的对象，则都不必重新实现数据结构，重新编写算法。

基本概念

• 容器：容纳各种数据类型的通用数据结构，是类模板
• 迭代器：可用于依次存取容器中元素，类似指针
• 算法：用来操作容器中的元素的函数模板
  • $sort()$ 来对一个vector 中的数据进行排序
  • *find()来搜索list()*中的对象
  • 算法本身与他们操作的数据的类型无关

int array[100];
sort(array, array+70); //将前70个元素进行排序
// 容器：数组
// 迭代器，int*类型的指针
// 算法：sort

容器

可以用于存放各种类型的数据（基本类型的变量，对象等）的数据结构，都是类模板

• 顺序容器：vector动态数组, deque双向队列, list双向链表
• 关联容器：set, multiset, map, multimap
• 容器适配器：stack, queue, priority_queue

对象被插入容器中时，被插入的是对象的一个复制品。许多算法，比如排序，查找，要求对容器中的元素进行比较，有的容器本身就是排序的，所以，放入容器的对象所属的类，往往还应该重载 == 和 < 运算符。

顺序容器

容器并非排序的，元素的插入位置同元素的值无关。

• vector：头文件 <vector>
  • 动态数组。元素在内存连续存放。随机存取任何元素都能在常数时间完成。在尾端增删元素具有较佳的性能(大部分情况下是常数时间，如果超出预分配空间的大小时为$O(n)$,此时需要重新分配空间）。在开头或者中间插入为$O(n)$.
• deque：头文件 <deque>
  • 双向队列。元素在内存连续存放。随机存取任何元素都能在常数时间完成(但次于vector: 考虑情况，$tail$指针在$head$的前方，此时在数据读取的过程中，需要多一步的逻辑判断)。相较于$vector$在两端增删元素具有较佳的性能(大部分情况下是常数时间）
  • 有两个指针：head, tail
• list：头文件 <list>
  • 双向链表。元素在内存不连续存放。在任何位置增删元素都能在常数时间完成( 元素位置确定的情况下)。不支持随机存取，即不能通过下标$i$直接访问元素。

关联容器

• 元素是排序的
• 插入任何元素，都按相应的排序规则来确定其位置
• 在查找时具有非常好的性能
• 通常以平衡二叉树方式实现，插入和检索的时间都是 $O(\log (N))$
• set/muitiset：头文件 <set>
  • 集合。set中不允许相同元素，multiset中允许存在相同的元素。
• map/multimap： 头文件 <map>
  • map与set的不同在于map中存放的元素有且仅有两个成员变量，一个名为 first,另一个名为 second, map根据 first 值对元素进行从小到大排序， 并可快速地根据 first 来检索元素。 $first$相当于关键字，$second$相当于$value$值。
  • map 同 multimap 的不同在于是否允许相同 first 值的元素。

容器适配器

• stack：头文件 <stack>
  • 栈。是项的有限序列，并满足序列中被删除、检索和修改的项只能是最近插入 序列的项（栈顶的项）。后进先出。
• queue：头文件 <queue>
  • 单向队列。插入只可以在尾部进行， 删除、检索和修改只允许从头部进行。先进先出。
• priority_queue： 头文件 <queue>
  • 优先级队列。最高优先级元素总是第一个出列

成员函数

顺序容器和关联容器共有：

• begin 返回指向容器中第一个元素的迭代器
• end 返回指向容器中最后一个元素后面的位置的迭代器
• rbegin 返回指向容器中最后一个元素的迭代器
• rend 返回指向容器中第一个元素前面的位置的迭代器
• erase 从容器中删除一个或几个元素
• clear 从容器中删除所有元素

顺序容器：

• front :返回容器中第一个元素的引用
• back : 返回容器中最后一个元素的引用
• push_back : 在容器末尾增加新元素
• pop_back : 删除容器末尾的元素
• erase :删除迭代器指向的元素(可能会使该迭代器失效），或删除一个区间，返回被删除元素后面的那个元素的迭代器

迭代器

• 用于指向顺序容器和关联容器中的元素
• 迭代器用法和指针类似
• 有 const 和非 const 两种
• 通过迭代器可以读取它指向的元素
• 通过非 const 迭代器还能修改其指向的元素

定义一个容器类的迭代器的方法：（容器类：从容器模板实例化出来的类）

容器类名::iterator 变量名;
容器类名::const_interator 变量名;

访问一个迭代器指向的元素：

*迭代器变量名

迭代器上可以执行 ++ 操作, 以使其指向容器中的下一个元素。 如果迭代器到达了容器中的最后一个元素的后面，此时再使用它，就会出错，类似于使用NULL或未初始化的指针一样。

例

#include <iostream>
#include <vector>
using namespace std;

int main()
{
  	vector<int> v; //一个存放int元素的数组，一开始里面没有元素。
  	v.push_back(1);
  	v.push_back(2);
  	v.push_back(3);//在尾部添加
  	vector<int>::const_iterator i; //常量迭代器。const:只能访问，不能修改
  	for (i = v.begin(); i != v.end(); i++) //注意v.end()返回的是最后一个元素的后一个位置
    {
      	cout << *i << ",";
    }
  	cout << endl;
  	// 反向迭代器
  	vector<int>::reverse_iterator r;//与iterator类型不兼容
  	for (r = v.rbegin(); r != v.rend(); r++)//对反响迭代器的++操作，会指向前一个元素
    {
		cout << *r << ",";
    }
  	cout << endl;
  	vector<int>::iterator j;//非常量迭代器
  	for (j = v.begin(); j != v.end(); j++)
    {
      	*j = 100;
    }
  	for (i = v.begin(); i != v.end(); i++)
    {
      	cout << *i << ",";
    }
  	return 0;
}

STL常用的迭代器有两种：双向迭代器和随机访问迭代器。

双向迭代器

可进行的操作：

• ++p, p++ 使 p 指向容器中下一个元素
• --p, p-- 使 p 指向容器中上一个元素
• *p 取p指向的值
• 赋值，判断相等 p==p1 p!=p1

随机访问迭代器

可进行的操作

• 双向迭代器的所有操作
• p += i 将p向后移动i个元素
• p -= i 将 p 向向前移动i个元素
• p + i 值为: 指向 p 后面的第i个元素的迭代器
• p - i 值为: 指向 p 前面的第i个元素的迭代器
• p[i] 值为: p后面的第i个元素的引用
• 比较大小< > p<p1: p指向的元素，在p1指向的元素的前面

容器	迭代器
vector	随机访问(下标访问)
deque	随机访问
list	双向
set/multiset	双向
map/mutimap	双向
stack	不支持
queue	不支持
priority_queue	不支持

遍历 vector

vector<int> v(100);
for (int i = 0; i < v.size(); i++)
{
  	cou << v[i];//通过下标随机访问
}
// 迭代器
vector<int>::const_iterator i;
for (i = v.begin(); i < v.end(); i++)
{
  	cout << *i;
}
// 间隔一个输出
i = v.begin();
while (i < v.end())
{
  	cout << *i;
  	i += 2;
}

遍历 list

list<int> v;
list<int>::const_iterator i;
for (i = v.begin(); i != v.end(); i++)  // 不可写成 i < v.end()。因为list上面的迭代器是双向迭代器，双向迭代器不能用<进行比较。
//list没有[]成员函数
{
  	cout << *i;
}

算法简介

• 算法就是一个个函数模板, 大多数在 <algorithm> 中定义
• STL中提供能在各种容器中通用的算法，比如查找，排序等
• 算法通过迭代器来操纵容器中的元素。许多算法可以对容器中的一个 局部区间进行操作，因此需要两个参数，一个是起始元素的迭代器， 一个是终止元素的后面一个元素的迭代器。比如，排序和查找
• 有的算法返回一个迭代器。比如 find() 算法，在容器中查找一个元 素，并返回一个指向该元素的迭代器
• 算法可以处理容器，也可以处理普通数组

示例：find()

原型：

template<class InIt, class T>
InIt find(InIt first, InIt last, const T &val);

• first 和 last 这两个参数都是容器的迭代器，它们给出了容器中的 查找区间起点和终点[first,last)，左闭右开。区间的起点是位于查找范围之中 的，而终点不是。find()在[first,last)查找等于val的元素
• 用==运算符判断相等
• 函数返回值是一个迭代器。如果找到，则该迭代器指向被找到的元素。 如果找不到，则该迭代器等于 last
• 顺序查找的时间复杂度是$O(n)$

#include <iostream>
#include <vector>
#include <algorithm>
using namesapce std;

int main()
{
  	int array[10] = { 10,20,30,40 };
  	vector<int> v;
  	v.push_back(1);
  	v.push_back(2);
  	v.push_back(3);
  	v.push_back(4);
  	vector<int>::iterator p;
  	p = find(v.begin(), v.end(), 3); //注意find()函数的返回值是一个迭代器
    //v.begin()也是一个迭代器
  	if (p != v.end())
    {
      	cout << *p << endl;
    }
  	p = find(v.begin(), v.end(), 9);
  	if (p == v.end())
    {
      	cout << "not found" << endl;
    }
  	p = find(v.begin() + 1, v.end() - 2, 1);//查找区间： [2,3);查找不到，会返回查找时地last,此处为3
  	if (p != v.end())
    {
      	cout << *p << endl;
    }
  	int *pp = find(array, array + 4, 20); // 数组名就是迭代器，因为数组名就是int*类型的指针
  	cout << *pp << endl;
  	return 0;
}

STL中的大小与相等

大小

• 关联容器内部的元素是从小到大排序的
• 有些算法要求其操作的区间是从小到大排序的，称为“有序区间算法” 例：binary_search
• 有些算法会对区间进行从小到大排序，称为“排序算法” 例： sort
• 可以认为对从小到大的概念进行定义，比如按照数字的个位数字的大小关系进行比较——自定义大小
• 还有一些其他算法会用到“大”，“小”的概念
• 使用STL时，在缺省的情况下，以下三个说法等价：
  • x比y小
  • op(x, y) 返回值为 true（op为自定义的比较函数）
  • y比x大

相等

x和y相等表示

• x==y
  • 例：在未排序的区间上进行的算法，如顺序查找find
• x小于y和y小于x同时为假，注意此处的小于可以自定义
  • 有序区间算法，如 binary_search
  • 关联容器自身的成员函数find

示例： STL中“相等”概念演示

#include <iostream>
#include <algorithm>
using namespace std;

class A
{
	int v;
public:
  	A(int n):v(n){}
  	bool operator<(const A &a2) const //运算符重载:两个class A的对象，一个都不会小于另一个
    {
      	cout << v << "<" << a2.v << "?" << endl;
      	return false;
    }
  	bool operator==(const A &a2) const //判断两个类是否相等
    {
      	cout << v << "==" << a2.v << "?" << endl;
      	return v == a2.v;
    }
};

int main()
{
  	A a[] = { A(1),A(2),A(3),A(4),A(5) };
  	cout << binary_search(a, a+4, A(9)); // 用 < 做比较，折半查找
  	return 0；
}

输出结果：

3<9? 
2<9? 
1<9? 
9<1? 
1

注意到在输出中没有用到==号，而是多次调用<。对程序而言，如果1<9不成立，同时9<1不成立，就会认为9=1

引用

https://www.coursera.org/learn/cpp-chengxu-sheji/lecture