《C++面向对象程序设计》课程笔记 lessen8

1. 标准模板库 STL 概述

1 泛型程序设计

C++中有两个方面体现重用：

• 面向对象的思想：继承和多态，标准类库
• 泛型程序设计（generic programming）的思想：模板机制，以及标准模板库 STL。  

泛型程序设计：简单的说就是使用模板的程序设计法。

将一些常用的数据结构（比如链表，数组，二叉树）写成类模板，算法（比如排序，查找）写成函数模板。 

标准模板库（STL）就是一些常用数据结构和算法的模板的集合。

• 容器：可容纳各种数据类型的通用数据结构，是类模板
• 迭代器：可用于依次存取容器中元素，类似于指针
• 算法：用来操作容器中的元素的函数模板 

                  sort() 来对一个 vector 中的数据进行排序。

                  find() 来搜索一个 list 中的对象。

算法本身与它们操作的数据的类型无关，因此它们可以在从简单数组到高度复杂容器的任何数据结构上使用。 

int array[100];

 该数组就是容器，而 int * 类型的指针变量就可以作为迭代器， sort 算法可以作用于该容器上，对其进行排序：

sort (array, array+70); //将前70个元素排序。

2 容器概述

• 顺序容器：vector，deque，list
• 关联容器：set，multiset，map，multimap
• 容器适配器：stack，queue，priority_queue 

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

2.1 顺序容器简介 

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

有  vector，deque，list 三种。

2.1.1 vector

• vector ：头文件 <vector> 

动态数组。元素在内存连续存放。随机存取任何元素都能在常数时间完成。在尾端增删元素具有较佳的性能（大部分情况下是常数时间，只有原先分配的内存不足，需重新分配内存的情况下才不是常数时间）。在头部和中间增删元素为O(N)时间。

2.1.2 deque 

• deque：头文件 <deque>  

双向队列。元素在内存连续存放。随机存取任何元素都能在常数时间完成（但次于 vector）。在两端增删元素具有较佳的性能（大部分情况下是常数时间）。 

2.1.3 list

• list： 头文件 <list>

双向链表。元素在内存不连续存放。在任何位置增删元素都能在常数时间完成。不支持随机存取。

2.2 关联容器简介

• 元素是排序的。
• 插入任何元素，都按相应的排序规则来确定其位置。
• 在查找时具有非常好的性能。
• 通常以平衡二叉树方式实现，插入和检索的时间都是 O(log(N)) 。

2.2.1 set/multiset 

• set/multiset：头文件 <set>

set 即集合。 set 中不允许相同元素，multiset 中允许存在相同的元素。

2.2.2 map/multimap

•  map/multimap：头文件 <map>

map 与 set 的不同在于 map 中存放的元素有且仅有两个成员变量，一个名为 first，另一个名为 second， map 根据 first 值对元素进行从小到大排序，并可快速地根据 first 来检索元素。（first：key；second：value）。

map 和 multimap 的不同在于是否允许相同 first 值的元素。 

2.3 容器适配器简介

2.3.1 stack

• stack：头文件 <stack> 

栈。是项的有限序列，并满足序列中被删除、检索和修改的项只能是最近插入序列的项（栈顶的项）。后进先出。 

2.3.2 queue

• queue：头文件 <queue> 

队列。插入只可以在尾部进行，删除、检索和修改只允许从头部进行。先进先出。 

2.3.3 priority_queue

• priority_queue：头文件 <queue>

优先级队列。最高优先级元素总是第一个出列。 

2.4 顺序容器和关联容器中都有的成员函数

2.5 顺序容器常用的成员函数

3 迭代器

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

 定义一个容器类的迭代器的方法可以是：

容器类名::iterator  变量名;

容器类名::const_iterator  变量名;

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

* 迭代器变量名

迭代器上可以执行 ++ 操作，以式其指向容器中的下一个元素。如果迭代器到达了容器中的最后一个元素的后面，此时再使用它，就会出错，类似于使用 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);
	v.push_back(4);
	vector<int>::const_iterator i; //常量迭代器
	for( i=v.begin();i!=v.end();i++)
		cout << *i << ",";
	cout << endl;
	vector<int>::reverse_iterator r; //反向迭代器
	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 << ",";

	system("pause");
	return 0;
}

3.2 双向迭代器

若 p 和 p1 都是双向迭代器，则可对 p、p1 可进行以下操作：

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

3.3 随机访问迭代器 

若 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，p > p1，p >= p1 

                     容器                                      容器上的迭代器类别

                vector、deque                                   随机访问

             list、set/multiset、map/multimap            双向

             stack、queue、priority_queue          不支持迭代器

有的算法，例如 sort ，binary_search 需要通过随机访问迭代器来访问容器中的元素，那么 list 以及关联容器就不支持该算法。   

vector 的迭代器是随机迭代器，遍历 vector 可以有以下几种做法（deque 亦然）：

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

list 的迭代器是双向迭代器，正确的遍历 list 的方法：

list<int> v;
list<int>::const_iterator ii;
for(ii=v.begin();ii!=v.end();ii++)
	cout << *ii;

错误的做法：

for(ii=v.begin();ii < v.end();ii++)
	cout << *ii;
for(int i=0;i<v.size();i++)
	cout << v[i];
//双向迭代器不支持 < ，list 没有 [] 成员。

4 算法简介

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

4.1 算法实例：find()  

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

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

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

int main()  
{//find 算法示例
	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); //包含v.begin()，不包含v.end()
	if(p!=v.end())
		cout << *p << endl; //输出3
	p = find(v.begin(),v.end(),9);
	if(p==v.end())
		cout << "not found" << endl;
	p = find(v.begin()+1,v.end()-2,1); //整个容器：[1,2,3,4]，查找区间：[2,3)
	if(p!=v.end())
		cout << *p << endl; //找不到，指向v.end()-2，输出3
	int * pp = find(array,array+4,20); //数组名是迭代器
	cout << *pp << endl;

	system("pause");
	return 0;
}