1 - STL简介

STL（Standard Template Library，标准模板库)是惠普实验室开发的一系列软件的统称。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时所开发出来

STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了模板类和模版函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。

只要我们熟悉了STL之后，许多代码可以被大大的化简，只需要通过调用一两个算法模板，就可以完成所需要的功能并大大地提升效率。

2 - 算法

STL库包含了100多个实现算法的模板函数，当我们熟悉掌握了这些算法后，STL可以帮助我们快速实现这些算法内容。提升了我们的代码效率

算法部分主要由头文件＜algorithm＞，＜numeric＞和＜functional＞组成。

＜algorithm＞是所有STL头文件中最大的一个（尽管它很好理解），它是由一大堆模版函数组成的，可以认为每个函数在很大程度上都是独立的，其中常用到的功能范围涉及到比较、交换、查找、遍历操作、复制、修改、移除、反转、排序、合并等等。
＜numeric＞体积很小，只包括几个在序列上面进行简单数学运算的模板函数，包括加法和乘法在序列上的一些操作。

＜functional＞中则定义了一些模板类，用以声明函数对象。

2.1 - sort(STL sort)排序算法：

//数据的插入--第一种：用insert函数插入pair数据  

#include <string>  
#include <iostream>  
#include<algorithm>
#include<vector>

using namespace std;

int main()

{
	vector<int> numbers = { 99,77,33,66,22,11,44,88 };
	vector<int>::iterator i;
	sort(numbers.begin(), numbers.end());
	for(i=numbers.begin();i!=numbers.end();++i)
	{
		cout << *i << " ";
	}


}

3 - 容器

在实际开发过程中，数据结构本身的重要性不会逊于操作于数据结构的算法的重要性，当程序中存在着对时间要求很高的部分时，数据结构的选择就显得更加重要。

经典的数据结构数量有限，但是我们常常重复着一些为了实现向量、链表等结构而编写的代码，这些代码都十分相似，只是为了适应不同数据的变化而在细节上有所出入。STL容器

就为我们提供了这样的方便，它允许我们重复利用已有的实现构造自己的特定类型下的数据结构，通过设置一些模版类，STL容器对最常用的数据结构提供了支持，这些模板的参数

允许我们指定容器中元素的数据类型，可以将我们许多重复而乏味的工作简化。

容器部分主要由头文件＜vector＞,＜list＞,＜deque＞,＜set＞,＜map＞,＜stack＞和＜queue＞组成。对于常用的一些容器和容器适配器（可以看作由其它容器实现的容器），可以通过下表总结一下它们和相应头文件的对应关系。

向量(vector) 连续存储的元素＜vector＞

列表(list) 由节点组成的双向链表，每个结点包含着一个元素＜list＞

双队列(deque) 连续存储的指向不同元素的指针所组成的数组＜deque＞

集合(set) 由节点组成的红黑树，每个节点都包含着一个元素，节点之间以某种作用于元素对的谓词排列，没有两个不同的元素能够拥有相同的次序 ＜set＞

多重集合(multiset) 允许存在两个次序相等的元素的集合 ＜set＞

栈(stack) 后进先出的值的排列 ＜stack＞

队列(queue) 先进先出的执的排列 ＜queue＞

优先队列(priority_queue) 元素的次序是由作用于所存储的值对上的某种谓词决定的的一种队列 ＜queue＞

映射(map) 由{键，值}对组成的集合，以某种作用于键对上的谓词排列 ＜map＞

多重映射(multimap) 允许键对有相等的次序的映射 ＜map＞

3.1 - 序列容器

序列容器以线性序列的方式存储元素。它没有对元素进行排序，元素的顺序和存储它们的顺序相同。本章将介绍 5 种标准的序列容器，每种容器都具有不同的特性：
array<T,N> (数组容器) ：是一个长度固定的序列，有 N 个 T 类型的对象，不能增加或删除元素。
vector (向量容器) ：是一个长度可变的序列，用来存放T类型的对象。必要时，可以自动增加容量，但只能在序列的末尾高效地增加或删除元素。
deque (双向队列容器) ：是一个长度可变的、可以自动增长的序列，在序列的两端都不能高效地增加或删除元素。
list (链表容器) 是一个长度可变的、由 T 类型对象组成的序列，它以双向链表的形式组织元素，在这个序列的任何地方都可以高效地增加或删除元素。访问容器中任意元素的速度要比前三种容器慢，这是因为 list 必须从第一个元素或最后一个元素开始访问，需要沿着链表移动，直到到达想要的元素。
forward list (正向链表容器) ：是一个长度可变的、由 T 类型对象组成的序列，它以单链表的形式组织元素，是一类比链表容器快、更节省内存的容器，但是它内部的元素只能从第一个元素开始访问。

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

int main()
{
	//定义不定长数组v
	vector<int> v;
	vector<int>::iterator i;	//定义迭代器i.用于操作数组元素
	//pushu_back:在数组末尾插入元素
	v.push_back(3);
	v.push_back(2);
	v.push_back(1);
	v.push_back(0);
	//依次输出数组中的元素
	for (i = v.begin(); i != v.end(); ++i)
	{
		cout << *i << " ";
	}
	cout << "\n";
	cout << *v.begin();

	//insert:插入元素
	v.insert(v.begin(), 4);	//在v.begin()之前插入4
	cout << "\n";
	for (i = v.begin(); i != v.end(); ++i)
	{
		cout << *i << " ";
	}
	//insert:插入元素
	v.insert(v.begin()+1, 5);	//在v.begin()+1之后插入5
	cout << "\n";
	for (i = v.begin(); i != v.end(); ++i)
	{
		cout << *i << " ";
	}
	v.insert(v.end(), 4);	//在v.end()之后插入4
	cout << "\n";
	for (i = v.begin(); i != v.end(); ++i)
	{
		cout << *i << " ";
	}
	//erase：删除元素
	v.erase(v.begin());
	cout << "\n";
	for (i = v.begin(); i != v.end(); ++i)
	{
		cout << *i << " ";
	}
	return 0;
}

3.2 - map容器

map 容器是关联容器的一种。在关联容器中，对象的位置取决于和它关联的键的值。键可以是基本类型，也可以是类类型。字符串经常被用来作为键，如果想要保存姓名和地址的记录，就可以这么使用。名称通常可能是一个或多个字符串。关联容器中的对象位置的确定取决于容器中的键的类型，而且对于特定容器类型的内部组织方式，不同的 STL 有不同的实现。

//数据的插入--第一种：用insert函数插入pair数据  
#include <map>  

#include <string>  

#include <iostream>  

using namespace std;

int main()

{

	map<int, string> mapStudent;

	mapStudent.insert(pair<int, string>(1, "student_one"));

	mapStudent.insert(pair<int, string>(2, "student_two"));

	mapStudent.insert(pair<int, string>(3, "student_three"));

	map<int, string>::iterator iter;

	for (iter = mapStudent.begin(); iter != mapStudent.end(); iter++)

		cout << iter->first << ' ' << iter->second << endl;

}

4 - 迭代器

概括来说，迭代器在STL中用来将算法和容器联系起来，起着一种黏和剂的作用。几乎STL提供的所有算法都是通过迭代器存取元素序列进行工作的，每一个容器都定义了其本身所专有的迭代器，用以存取容器中的元素。

迭代器部分主要由头文件＜utility＞,＜iterator＞和＜memory＞组成。

＜utility＞是一个很小的头文件，它包括了贯穿使用在STL中的几个模板的声明，

＜iterator＞中提供了迭代器使用的许多方法，而对于＜memory＞的描述则十分的困难，它以不同寻常的方式为容器中的元素分配存储空间，同时也为某些算法执行期间产生的临时对象提供机制,＜memory＞中的主要部分是模板类allocator，它负责产生所有容器中的默认分配器

可以通过迭代器方便的指向容器元素的下标或者说是地址