STL

•STL（标准模板库）: 是C++标准程序库的核心，是一个泛型程序库，提供了一系列软件方案，利用先进，高效的算法来管理数据。从程序员角度看，STL是由一些可适应不同需求的群集类别和一些能够在这些数据群集上运作的算法构成。STL内部的所有组件都由template构成，所以其元素可以是任意型别。
•STL组件：最关键的是容器（container），算法（algorithm），迭代器（iterator）

•STL的基本观念就是将数据和操作分离。数据由容器类别加以管理，操作则由可定制的算法定义之。迭代器在两者之间充当粘合剂，使任何算法都可以和任何容器交互运作。

STL将数据和算法分开对待，而不是合并考虑。从某种意义上说，STL的概念和面向对象程序设计（OOP）的最初思想是矛盾的。但是，这么做有很重要的原因：你可以将各种容器与各种算法结合起来，在很小的框架内拥有非常大的弹性。
STL的一个根本特性是，所有组件都可以针对任意型别运作。
STL还提供了更泛型化的组件，通过特定的配接器和仿函数，你可以补充，约束或定制算法，以满足特别需求。

•【容器】：用来管理某类对象的集合。容纳特定数据类型对象的集合,STL容器是将最常用的一些数据结构实现出来.包含了许多数据结构,如:vector,queue,statck…,string也可以看作是一个容器.
•分类:容器用来管理一组元素，为了适应不同需要，STL根据数据在容器中排列的特性,容器可分为序列式容器和关联式容器两种.
•序列式容器:可序群集，其中每个元素都有固定位置——取决于插入时机和地点,与元素的值没有关系,如果你以追加方式对一个群集置入n个元素，它们的排列次序将和置入次序一致。如vector,deque,list
•关联式容器:已序群集，元素位置取决于特定的排序准则,和插入顺序无关。如果你将n个元素置入这样的群集中，它们的位置取决于元素值，和插入次序无关。STL提供了4个这样的容器：set，map，multiset，multimap。
关联式容器也可被视为特殊的序列式容器，因为已序群集正是根据某个排序准则排列而成。

•【算法】：用来处理群集内的元素。它们可以出于不同的目的而搜寻，排序，修改，使用那些元素。是一种应用在容器上以各种方法处理其内存的行为或功能,如sort(排序),copy(拷贝)…,算法由模板函数体现,这些函数不是容器类的成员函数，是独立的函数,它们可以用于STL容器,也可以用于普通的C++数组等.
•头文件：#include<algorithm>在STL的泛型算法中有4类基本的算法：
•1)变序型队列算法: 可以改变容器内的数据； 
•2)非变序型队列算法:处理容器内的数据而不改变他们； 
•3)排序值算法:包涵对容器中的值进行排序和合并的算法，还有二叉搜索算法；
•4)通用数值算法：此种算法不多，涉及到专业领域中有用的算术操作，独立包涵于头文件<numeric>中，在此不多做解释

STL的算法并不只是针对STL容器，对一般容器也是适用的。
变序型队列算法  

#include <iostream>
#include <algorithm>
#include <iterator>				//下面用到了输出迭代器ostream_iterator
using namespace std;
int main(void)
{
	int arr[6] = {1,12,3,2,1215,90};
	int arr1[7];
	int arr2[6] = {2,5,6,9,0,-56};
	copy(arr,(arr+6),arr1);				//将数组aar复制到arr1
	cout<<"arr[6] copy to arr1[7],now arr1: "<<endl;
	for(int i = 0;i<7;i++) 	cout<<" "<<arr1[i];
	reverse(arr,arr+6);					//将排好序的arr翻转
	cout<<"\n"<<"arr reversed ,now arr:"<<endl;
	copy(arr,arr+6,ostream_iterator<int>(cout, " "));		//复制到输出迭代器
	swap_ranges(arr,arr+6,arr2);		//交换arr和arr2序列
	cout<<"\n"<<"arr swaped to arr2,now arr:"<<endl;
	copy(arr,arr+6,ostream_iterator<int>(cout, " "));
	cout<<"\n"<<"arr2:"<<endl;
	copy(arr2,arr2+6,ostream_iterator<int>(cout, " "));
	return 0;
}

非变序型队列算法

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(void){
	int a[10] = {12,31,5,2,23,121,0,89,34,66};
	vector<int> v1(a,a+10);
	vector<int>::iterator result1,result2;//result1和result2是随机访问迭代器
	result1 = find(v1.begin(),v1.end(),2);
	//在v1中找到2，result1指向v1中的2 
	result2 = find(v1.begin(),v1.end(),8);
	//在v1中没有找到8，result2指向的是v1.end() 
	cout<<result1-v1.begin()<<endl; //3－0＝3或4－1＝3，屏幕结果是3
	cout<<result2-v1.end()<<endl;    
	int b[9] = {5,2,23,54,5,5,5,2,2};
	vector<int> v2(a+2,a+8);
	vector<int> v3(b,b+4);
	result1 = search(v1.begin(),v1.end(),v2.begin(),v2.end());
	cout<<*result1<<endl; 
	//在v1中找到了序列v2，result1指向v2在v1中开始的位置 
	result1 = search(v1.begin(),v1.end(),v3.begin(),v3.end());
	cout<<*(result1-1)<<endl;
	//在v1中没有找到序列v3，result指向v1.end(),屏幕打印出v1的最后一个元素66    
	vector<int> v4(b,b+9); 
	int i = count(v4.begin(),v4.end(),5);
	int j = count(v4.begin(),v4.end(),2);
	cout<<"there are "<<i<<" members in v4 equel to 5"<<endl;
	cout<<"there are "<<j<<" members in v4 equel to 2"<<endl; 
	//计算v4中有多少个成员等于 5,2
	return 0;        
}

排序值算法

#include <iostream>
#include <algorithm>
using namespace std;
int main(void)
{
	int a[10] = {12,0,5,3,6,8,9,34,32,18};
	int b[5] = {5,3,6,8,9};
	int d[15];
	sort(a,a+10);
	for(int i = 0;i<10;i++)
		cout<<" "<<a[i];
	sort(b,b+5);				// 3 5 6 8 8
	if(includes(a,a+10,b,b+5))		//一个数组是否包含另外一个数组
		cout<<"\n"<<"sorted b members are included in a."<<endl;
	else
		cout<<"sorted a dosn`t contain sorted b!";
	merge(a,a+10,b,b+5,d);			//合并
	for(int j = 0;j<15;j++)     
		cout<<"  "<< d[j]; 
	return 0;
}

•【迭代器】：用来在一个对象群集的元素上进行遍历动作。这个对象群集或许是个容器，或许是容器的一部分。迭代器的主要好处是，为所有容器提供了一组很小的公共接口，利用这个接口，某项操作就可以行进至群集内的下一个元素。每一种容器都提供了自己的迭代器，而这些迭代器了解该种容器的内部结构，所以能够知道如何正确行进。迭代器的接口和一般指针差不多。
•可将其看作是一个指向容器中元素的普通指针,用迭代器来访问容器中的元素,是它将算法和容器连接在一起,每个容器都有自己的迭代器,只有容器自己才知道如何访问自己的元素。

•【函数对象】：
•算数类： plus<T> --加,minus<T> --减,multiplies<T> --乘,
divides<T> --除,modulus<T> --模,negate<T> --否定
•关系类： equal_to<T> --等于，not_equal_to<T>--不等于，
greater<T>--大于，greater_equal<T>--大于等于,
less<T>--小于，less_equal<T>--小于等于
•逻辑运算： logical_and<T> --与
logical_or<T> --或
logical_not<T> --非

•容器类别的共通操作函数
ContType c           产生一个空容器
ContType c1(c2)   产生一个同型容器
ContType c3(beg,end) 用[beg,end]区间值给容器赋初值
C.~ContType()     析构，释放内存
C.size()                 返回容器中的元素数量
C.empty()             判断容器是否为空
C.max_size()       返回元素的最大可能数量
c1 == c2 判断是否c1等于c2
c1 != c2 判断是否c1不等于c2
c1 < c2         判断是否c1小于c2
c1 > c2 判断是否c1大于c2
c1<=c2           判断是否c1小于等于c2
c1>=c2         判断是否c1大于等于c2
c1 = c2 将c2的所有元素赋值给c1
c1.swap(c2)   交换c1和c2的数据
swap(c1,c2)   同上，是全局函数
c.clear() 移除所有元素，使容器为空
c.erase(beg,end) 移除[beg,end]区间内所有元素，某些容器会 返回未被移除的第一个接续元素
c.insert(pos,elem) 将elem的一份副本安插于pos处，返回值和pos的意义并不相同
c.begin() 返回一个迭代器，指向第一元素
c.end() 返回一个迭代器，指向最后元素下一个位置
c.rbegin() 返回一个逆向迭代器，指向逆向遍历时第一元素
c.rend() 返回一个逆向迭代器，指向逆向遍历时最后元素的下一位置
c.get_allocator() 返回容器的内存模型