STL学习心得
STL概述：
nSTL是C++标准程序库的核心，深刻影响了标准程序库的整体结构
nSTL由一些可适应不同需求的集合类（collection class），以及在这些数据集合上操作的算法（algorithm）构成
nSTL内的所有组件都由模板（template）构成，其元素可以是任意类型
nSTL是所有C++编译器和所有操作系统平台都支持的一种库
STL组件：
Ø 容器（Container） － 管理某类对象的集合
Ø 迭代器（Iterator） － 在对象集合上进行遍历
Ø 算法（Algorithm） － 处理集合内的元素
Ø 容器适配器（container adaptor）
Ø 函数对象(functor)
容器à迭代器à算法à容器
STL容器类别：
Ø 序列式容器－排列次序取决于插入时机和位置
Ø 关联式容器－排列顺序取决于特定准则
STL容器的共同能力
1.所有容器中存放的都是值而非引用。如果希望存放的不是副本，容器元素只能是指针。
2.所有元素都形成一个次序（order），可以按相同的次序一次或多次遍历每个元素
STL容器元素的条件
必须能够通过拷贝构造函数进行复制
必须可以通过赋值运算符完成赋值操作
必须可以通过析构函数完称销毁动作
序列式容器元素的默认构造函数必须可用
某些动作必须定义operator ==，例如搜寻操作
关联式容器必须定义出排序准则，默认情况是重载operator <
对于基本数据类型（int,long,char,double,…）而言，以上条件总是满足
n STL容器的共同操作
Ø 初始化（initialization）
F 产生一个空容器
Std::list<int>l;
F 以另一个容器元素为初值完成初始化
Std::list<int>l;
…
Std::vector<float>c(l.begin(),l.end());
F 以数组元素为初值完成初始化
Int array[]={2,4,6,1345};
…
Std::set<int>c(array,array+sizeof(array)/sizeof(array[0]));
STl容器的共同操作
Ø 与大小相关的操作（size operator）
F size()－返回当前容器的元素数量
F empty()－判断容器是否为空
F max_size()－返回容器能容纳的最大元素数量
Ø 比较（comparison）
F ==,!=,<,<=,>,>=
F 比较操作两端的容器必须属于同一类型
F 如果两个容器内的所有元素按序相等，那么这两个容器相等
F 采用字典式顺序判断某个容器是否小于另一个容器
n STL容器的共同操作
Ø 赋值（assignment）和交换（swap）
F swap用于提高赋值操作效率
Ø 与迭代器（iterator）相关的操作
F begin()－返回一个迭代器，指向第一个元素
F end()－返回一个迭代器，指向最后一个元素之后
F rbegin()－返回一个逆向迭代器，指向逆向遍历的第一个元素
F rend()－返回一个逆向迭代器，指向逆向遍历的最后一个元素之后
Ø 元素操作
F insert(pos,e)－将元素e的拷贝安插于迭代器pos所指的位置
F erase(beg,end)－移除[beg，end]区间内的所有元素
F clear()－移除所有元素
n 迭代器（iterator）（示例:iterator）
Ø 可遍历STL容器内全部或部分元素的对象
Ø 指出容器中的一个特定位置
Ø 迭代器的基本操作
操作 |
效果 |
* |
返回当前位置上的元素值。如果该元素有成员， 可以通过迭代器以operator ->取用 |
++ |
将迭代器前进至下一元素 |
==和!= |
判断两个迭代器是否指向同一位置 |
= |
为迭代器赋值（将所指元素的位置赋值过去） |
n 迭代器（iterator）
Ø 所有容器都提供获得迭代器的函数
操作 |
效果 |
begin() |
返回一个迭代器，指向第一个元素 |
end() |
返回一个迭代器，指向最后一个元素之后 |
半开区间[beg, end)的好处：
1.为遍历元素时循环的结束时机提供了简单的判断依据（只要未到达end()，循环就可以继续）
2.不必对空区间采取特殊处理（空区间的begin()就等于end()）
n 所有容器都提供两种迭代器
u container::iterator以“读/写”模式遍历元素
u container::const_iterator以“只读”模式遍历元素
Ø 迭代器示例：iterator
n 迭代器分类
u双向迭代器
l 可以双向行进,以递增运算前进或以递减运算后退、可以用==和!=比较。
例如：
list<int> l;
for(pos=l.begin();pos!=l.end();++pos{
…
}
l list、set和map提供双向迭代器
u随机存取迭代器
l 除了具备双向迭代器的所有属性，还具备随机访问能力。
l 可以对迭代器增加或减少一个偏移量、处理迭代器之间的距离或者使用<和>之类的关系运算符比较两个迭代器。
例如：
vector<int> v;
for(pos=v.begin();pos<v.end();++pos{
…
}
l vector、deque和string提供随机存取迭代器
² vector
n vector模拟动态数组
n vector的元素可以是任意类型T，但必须具备赋值和拷贝能力（具有public拷贝构造函数和重载的赋值操作符）
n 必须包含的头文件#include <vector>
n vector支持随机存取
n vector的大小（size）和容量（capacity）
u size返回实际元素个数，
u capacity返回vector能容纳的元素最大数量。如果插入元素时，元素个数超过capacity，需要重新配置内部存储器。
² vector
n 构造、拷贝和析构
操作 |
效果 |
vector<T> c |
产生空的vector |
vector<T> c1(c2) |
产生同类型的c1，并将复制c2的所有元素 |
vector<T> c(n) |
利用类型T的默认构造函数和拷贝构造函数生成一个大小为n的vector |
vector<T> c(n,e) |
产生一个大小为n的vector，每个元素都是e |
vector<T> c(beg,end) |
产生一个vector，以区间[beg,end]为元素初值 |
~vector<T>() |
销毁所有元素并释放内存。 |
à非变动操作
操作 |
效果 |
c.size() |
返回元素个数 |
c.empty() |
判断容器是否为空 |
c.max_size() |
返回元素最大可能数量（固定值） |
c.capacity() |
返回重新分配空间前可容纳的最大元素数量 |
c.reserve(n) |
扩大容量为n |
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 |
c.assign(n,e) |
将元素e的n个拷贝赋值给c |
c.assign(beg,end) |
将区间[beg,end]的元素赋值给c |
c1.swap(c2) |
将c1和c2元素互换 |
swap(c1,c2) |
同上，全局函数 |
std::list<T>l;
std::vector<T> v;
…
v.assign(l.begin(),l.end());
注意：
所有的赋值操作都有可能调用元素类型的默认构造函数，拷贝构造函数，赋值操作符和析构函数
à元素存取
操作 |
效果 |
|
at(idx) |
返回索引idx所标识的元素的引用，进行越界检查 |
|
operator [](idx) |
返回索引idx所标识的元素的引用，不进行越界检查 |
|
front() |
返回第一个元素的引用，不检查元素是否存在 |
|
back() |
返回最后一个元素的引用，不检查元素是否存在 |
|
Ø 迭代器相关函数
操作 |
效果 |
begin() |
返回一个迭代器，指向第一个元素 |
end() |
返回一个迭代器，指向最后一个元素之后 |
rbegin() |
返回一个逆向迭代器，指向逆向遍历的第一个元素 |
rend() |
返回一个逆向迭代器，指向逆向遍历的最后一个元素 |
迭代器持续有效，除非发生以下两种情况：
（1）删除或插入元素
（2）容量变化而引起内存重新分配
Ø 安插（insert）元素
操作 |
效果 |
c.insert(pos,e) |
在pos位置插入元素e的副本，并返回新元素位置 |
c.insert(pos,n,e) |
在pos位置插入n个元素e的副本 |
c.insert(pos,beg,end) |
在pos位置插入区间[beg,end]内所有元素的副本 |
c.push_back(e) |
在尾部添加一个元素e的副本 |
Ø 移除（remove）元素
操作 |
效果 |
c.pop_back() |
移除最后一个元素但不返回最后一个元素 |
c.erase(pos) |
删除pos位置的元素，返回下一个元素的位置 |
c.erase(beg,end) |
删除区间[beg,end]内所有元素，返回下一个元素的位置 |
c.clear() |
移除所有元素，清空容器 |
c.resize(num) |
将元素数量改为num（增加的元素用defalut构造函数产生，多余的元素被删除） |
c.resize(num,e) |
将元素数量改为num（增加的元素是e的副本） |
n map/multimap
Ø 使用平衡二叉树管理元素
Ø 元素包含两部分(key,value)，key和value可以是任意类型
Ø 必须包含的头文件#include <map>
Ø 根据元素的key自动对元素排序，因此根据元素的key进行定位很快，但根据元素的value定位很慢
Ø 不能直接改变元素的key，可以通过operator []直接存取元素值
Ø map中不允许key相同的元素，multimap允许key相同的元素
内部存储结构
构造、拷贝和析构
操作 |
效果 |
map c |
产生空的map |
map c1(c2) |
产生同类型的c1，并复制c2的所有元素 |
map c(op) |
以op为排序准则产生一个空的map |
map c(beg,end) |
以区间[beg,end]内的元素产生一个map |
map c(beg,end,op) |
以op为排序准则，以区间[beg,end]内的元素产生一个map |
~ map() |
销毁所有元素并释放内存。 |
其中map可以是下列形式
map<key,value> 一个以less（<）为排序准则的map，
map<key,value,op> 一个以op为排序准则的map
Ø 非变动性操作
操作 |
效果 |
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 |
Ø 特殊搜寻操作
操作 |
效果 |
count(key) |
返回”键值等于key”的元素个数 |
find(key) |
返回”键值等于key”的第一个元素，找不到返回end |
lower_bound(key) |
返回”键值大于等于key”的第一个元素 |
upper_bound(key) |
返回”键值大于key”的第一个元素 |
equal_range(key) |
返回”键值等于key”的元素区间 |
Ø 迭代器相关函数
操作 |
效果 |
begin() |
返回一个双向迭代器，指向第一个元素 |
end() |
返回一个双向迭代器，指向最后一个元素之后 |
rbegin() |
返回一个逆向迭代器，指向逆向遍历的第一个元素 |
rend() |
返回一个逆向迭代器，指向逆向遍历的最后一个元素 |
Ø 安插（insert）元素
操作 |
效果 |
c.insert(pos,e) |
在pos位置为起点插入e的副本，并返回新元素位置（插入速度取决于pos） |
c.insert(e) |
插入e的副本，并返回新元素位置 |
c.insert(beg,end) |
将区间[beg,end]内所有元素的副本插入到c中 |
Ø 移除（remove）元素
操作 |
效果 |
c.erase(pos) |
删除迭代器pos所指位置的元素，无返回值 |
c.erase(val) |
移除所有值为val的元素，返回移除元素个数 |
c.erase(beg,end) |
删除区间[beg,end]内所有元素，无返回值 |
c.clear() |
移除所有元素，清空容器 |
Ø map应用实例：map
Ø multimap应用实例：multimap
Ø set/multiset
Ø 使用平衡二叉树管理元素
Ø 集合(Set)是一种包含已排序对象的关联容器。
Ø 必须包含的头文件#include <set>
Ø map容器是键-值对的集合，好比以人名为键的地址和电话号码。相反地，set容器只是单纯的键的集合。当我们想知道某位用户是否存在时，使用set容器是最合适的。
Ø set中不允许key相同的元素，multiset允许key相同的元素
操作 |
效果 |
返回指向第一个元素的迭代器 |
|
清除所有元素 |
|
返回某个值元素的个数 |
|
如果集合为空，返回true |
|
返回指向最后一个元素的迭代器 |
|
返回集合中与给定值相等的上下限的两个迭代器 |
|
删除集合中的元素 |
|
返回一个指向被查找到元素的迭代器 |
|
返回集合的分配器 |
|
操作 |
|
在集合中插入元素 |
|
返回指向大于（或等于）某值的第一个元素的迭代器 |
|
返回一个用于元素间值比较的函数 |
|
返回集合能容纳的元素的最大限值 |
|
返回指向集合中最后一个元素的反向迭代器 |
|
返回指向集合中第一个元素的反向迭代器 |
|
集合中元素的数目 |
|
交换两个集合变量 |
|
返回大于某个值元素的迭代器 |
|
返回一个用于比较元素间的值的函数 |
#include <iostream>
#include <map>
using namespace std;
ostream & operator <<( ostream & o,constpair< int,double> & p)
{
o<< "(" << p.first << "," << p.second << ")";
returno;
}
int main() {
typedefmap<int,double,less<int> > mmid;
mmidpairs;
cout<< "1) " << pairs.count(15) << endl;
pairs.insert(mmid::value_type(15,2.7));
pairs.insert(make_pair(15,99.3));//make_pair生成一个pair对象
cout<< "2) " << pairs.count(15) << endl;
pairs.insert(mmid::value_type(20,9.3));
mmid::iteratori;
cout<< "3) ";
for( i =pairs.begin(); i != pairs.end();i ++ )
cout<< * i << ",";
输出：
1) 0
2) 1
3) (15,2.7),(20,9.3),
4) (15,2.7),(20,9.3),(40,0),
5) (15,6.28),(20,9.3),(40,0),
Algorithm（算法）：
n 泛型算法通则
Ø 所有算法的前两个参数都是一对iterators：[first，last)，用来指出容器内一个范围内的元素。
Ø 每个算法的声明中，都表现出它所需要的最低层次的iterator类型。
n 泛型算法通则
Ø 大部分算法都可以用functioin object 来更改准则。function object又称functor。
count:
template<class InIt, class T>
size_t count(InIt first, InIt last, const T& val);
计算[first,last) 中等于val的元素个数
count_if
template<class InIt, class Pred, class Dist>
size_t count_if(InIt first, InIt last, Pred pr);
计算[first,last) 中符合pr(e) ==true 的元素 e的个数
min_element:
template<class FwdIt>
FwdIt min_element(FwdIt first, FwdIt last);
返回[first,last) 中最小元素的迭代器,以 “< ”作比较器
max_element:
template<class FwdIt>
FwdIt max_element(FwdIt first, FwdIt last);
返回[first,last) 中最大(不小）元素的迭代器,以 “< ”作比较器
for_each
template<class InIt, class Fun>
Fun for_each(InIt first, InIt last, Fun f);
对[first,last)中的每个元素 e ,执行f(e) , 要求 f(e)不能改变e
排序和查找算法
1) find
template<class InIt, class T>
InIt find(InIt first, InIt last, const T& val);
返回区间 [first,last) 中的迭代器 i ,使得* i == val
2) find_if
template<class InIt, class Pred>
InIt find_if(InIt first, InIt last, Pred pr);
返回区间 [first,last) 中的迭代器 i, 使得pr(*i) == true
3) binary_search 折半查找，要求容器已经有序且支持随机访问迭代器，返回是否找到
template<class FwdIt, class T>
bool binary_search(FwdItfirst, FwdIt last, const T& val);
上面这个版本，比较两个元素x,y 大小时, 看x < y
template<class FwdIt, class T, class Pred>
bool binary_search(FwdIt first, FwdIt last, constT& val, Pred pr);
上面这个版本，比较两个元素x,y 大小时, 看pr(x,y)
4) lower_bound,uper_bound, equal_range
lower_bound：
template<classFwdIt, class T>
FwdIt lower_bound(FwdIt first, FwdIt last, constT& val);
要求[first,last)是有序的，
查找大于等于val的最小的位置
5)sort 快速排序
template<class RanIt>
void sort(RanIt first, RanIt last);
按升序排序。判断x是否应比y靠前，就看 x < y 是否为true
template<class RanIt, class Pred>
void sort(RanIt first, RanIt last, Pred pr);
按升序排序。判断x是否应比y靠前，就看 pr(x,y) 是否为true
reverse
template<class BidIt>
void reverse(BidIt first, BidIt last);
颠倒区间[first,last)顺序