STL——概述

1. C++语言的核心优势之一就是便于软件的重用。
2. C++中有两个方面体现重用：

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

一. 泛型程序设计

• 简单地说就是使用模板的程序设计法。
• 将一些常用的数据结构（比如链表，数组，二叉树）和算法（比如排序，查找）写成模板，以后则不论数据结构里放的是什么对象，算法针对什么样的对象，则都不必重新实现数据结构，重新编写算法。
• 标准库函数（Standard Template Library）就是一些常用数据结构和算法的模板的集合。
• 有了STL，不必再写大多的标准数据结构和算法，并且可获得非常高的性能。

二. STL中的基本的概念

1. 容器：可容纳各种数据类型的通用数据结构，是类模板。
2. 迭代器：可用于一次存取容器的元素，类似于指针。
3. 算法：用来操作容器中的元素的函数模板
   sort()函数来对一个vector中的数据进行排序
find()来搜索一个list中的对象
4. 算法本身与他们操作的数据的类型无关，因此他们可以在从简单数组到高度复杂容器的任何数据结构上使用。
5. 例如：

int array[100];
该数组就是容器，而int * 类型的指针变量就可以作为迭代器，sort算法可以作用于该容器上，对其进行排序；
sort(array, array+70);  //将前70个元素排序，其中array 和array+70 就是迭代器 

三. 容器概述

1. 可以用于存放各种类型的数据（基本类型的变量，对象等）的数据结构，都是类模板，分为3种：
2. 顺序容器： vector，deque，list
3. 关联容器：set,multiset,map,multimap
4. 容器适配器：stack,queue,priority_queue
5. 对象被插入容器中时，被插入的是对象的一个复制品。许多算法，比如排序，查找，要求对算法中的元素进行比较，有的容器本身就是排序的，所以，放入容器的对象所属的类，往往还应该重载 == 和 < 运算符。

(一). 顺序容器简介

1. 容器并非排序的，元素的插入位置同元素的值无关。
2. 有vector，deque，list三种

(1). vector

头文件   #include<vector>

• 动态数组。元素在内存连续存放。随机存取任何元素都能在常数时间完成。在尾端增删元素具有较佳的性能（大部分情况下是常数时间。

(2). deque

头文件   #include<deque>

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

(3). list

头文件   #include<list>

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

(二).关联容器简介

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

(1).set / multiset

头文件   #include<set>

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

(2).map / multimap

头文件   #include<map>

• map和set的区别在于map中存放的元素犹且仅有两个成员变量，一个为first，另一个名为second，map根据first值对元素进行从小到大排序，并可快速的根据first来检索元素。
• map同multimap的不同在于map不允许两个元素的first值相同，但是multimap可以。

(三). 容器适配器简介

(1). stack

头文件   #include<stack>

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

(2). queue

头文件   #include<queue>

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

(3). priority_queue

头文件   #include<queue>

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

(4). 顺序容器和关联容器中都有的成员函数

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

(5). 顺序容器的常用成员函数

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

四. 迭代器

(一). 概念

1. 用于指向顺序容器和关联容器中的元素
2. 迭代器用法和指针类似
3. 有const和非const两种
4. 通过迭代器可以读取它指向的元素
5. 通过非const迭代器还能修改其指向的元素
6. 定义一个容器类的迭代器的方法可以是：
   容器类名::iterator 变量名; 或 容器类名::const_iterator 变量名;
7. 访问一个迭代器指向的元素：* 迭代器变量名
8. 迭代器上可以执行 ++操作 ，以使其指向容器中的下一个元素。如果迭代器到达了容器中的最后一个元素的后面，此时再使用它，就会出错，类似于使用BULL或未初始化的指针一样。
9. 迭代器示例：

#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 << ",";
	cout << endl;
	return 0;
 } 

运行结果：

(二). 双向迭代器

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

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

(三). 随机访问迭代器

若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

(四). 容器的迭代器类别

五. 算法简介

(一). 概念

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

(二). 算法示例：find()

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int main()
{
	int a[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);
	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);
	if(p!=v.end())
		cout << *p << endl;
	int *pp = find(a,a+4,20);
	cout << *pp << endl;
	return 0;
 } 

运行结果：