一．概念
1. STL由一些可适应不同需求的集合类，以及在这些数据集合上操作的算法构成
2. STL中的三个主要组件
1）容器：用于存放数据的类模板，管理某类对象的集合
2）迭代器：在对象集合上进行遍历。是一个变量，作用类似于指针，访问容器中的元素需要通过迭代器
3）算法：用来操作容器中元素的函数模板
二．容器
1.要点
1）可以存放基本类型的变量，也可以存放对象
2）被放入容器中的对象所属的类最好重载”==”和”<”运算符
3）所有容器中存放的都是值而非引用。如果希望存放的不是副本，容器元素只能是指针
2.STL容器元素的条件
必须能够通过拷贝构造函数进行复制
必须可以通过赋值运算符完成赋值操作
必须可以通过析构函数完称销毁动作
序列式容器元素的默认构造函数必须可用
某些动作必须定义operator ==，例如搜寻操作
关联式容器必须定义出排序准则，默认情况是重载operator <
对于基本数据类型（int,long,char,double,…）而言，以上条件总是满足
3.容器的分类
1）序列式容器：
排列次序取决于插入时机和位置。即容器不是排序的，指定在什么位置插入，元素就在什么位置。
可变长动态数组vector，双端队列deque，双向链表list.
2）关联式容器：
排列顺序取决于特定的准则。即插入元素时，容器会按照一定的排序规则将元素放到适当的位置上，因此插入元素时不能指定位置。默认元素（或关键字）从小到大排序（”<”）
set，multiset，map，multimap
3）容器适配器——特殊性顺序表
stack,queue ,priority_queue
4.初始化
1）产生一个空容器：std::list<int> l;
2）以另一个容器元素为初值完成初始化：
std::list<int>l;
…
std::vector<float>c(l.begin(),l.end());
3）以数组元素为初值完成初始化
intarray[]={2,4,6,1345};
…
std::set<int>c(array,array+sizeof(array)/sizeof(array[0]));
5．比较
任何两个容器对象，只要他们的类型相同，就可以用==,!=,<,<=,>,>= 进行比较
1） a==b : a和b中的元素个数相同且对应元素相等
2） a<b : 从头到尾比较每个元素，若发生a中的元素小于b中的元素的情况，则a<b的值为ture;若没有发生b中的元素小于a中的元素的情况，且a中的元素个数比b中的少，则a<b的值为ture，其他情况下为false
3） a!=b ：等价于!(a==b)
4） a>b ：等价于b<a
5） a<=b ：等价于!(b<a)
6） a>=b ：等价于!(a<b)
6.容器的成员函数
1） 与大小相关的操作
int size()－返回当前容器的元素数量
bool empty()－判断容器是否为空
max_size()－返回容器能容纳的最大元素数量
2) 交换
swap--用于提高赋值操作效率
3) 与迭代器相关的操作
begin()－返回一个迭代器，指向第一个元素
end()－返回一个迭代器，指向最后一个元素之后
rbegin()－返回一个逆向迭代器，指向逆向遍历的第一个元素
rend()－返回一个逆向迭代器，指向逆向遍历的最后一个元素之后
4) 元素操作
insert(pos,e)－将元素e的拷贝安插于迭代器pos所指的位置
erase(beg,end)－移除[beg，end]区间内的所有元素
clear()－移除所有元素
front():返回容器中第一个元素的引用
back():返回容器中最后一个元素的引用
push_back:在容器末尾增加新元素
pop_back:删除容器末尾的元素
7.vector模拟动态数组
能够存放任意类型的元素
1）构造，拷贝和析构
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>() |
销毁所有元素并释放内存 |
2）.非变动操作
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 |
3）赋值操作
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) |
同上，全局函数 |
注：所有的赋值操作都有可能调用元素类型的默认构造函数，拷贝构造函数，赋值操作符和析构函数
4）元素存取
at(idx) |
返回索引idx所标识的元素的引用，进行越界检查 |
operator [](idx) |
返回索引idx所标识的元素的引用，不进行越界检查 |
front() |
返回第一个元素的引用，不检查元素是否存在 |
back() |
返回最后一个元素的引用，不检查元素是否存在 |
5）迭代器相关函数
同容器
注：迭代器持续有效，除非发生以下两种情况：
（1）删除或插入元素
（2）容量变化而引起内存重新分配
6）安插元素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的副本 |
7） 移除元素
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的副本） |
8.map/multimap
元素包含两部分(key,value)，key和value可以是任意类型
根据元素的key自动对元素排序
不能直接改变元素的key，可以通过operator []直接存取元素值
map中不允许key相同的元素，multimap允许key相同的元素
1）构造、拷贝和析构
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
2）非变动性操作
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 |
3）赋值
c1 = c2 |
将c2的全部元素赋值给c1 |
c1.swap(c2) |
将c1和c2的元素互换 |
swap(c1,c2) |
同上，全局函数 |
4）特殊搜寻操作
count(key) |
返回”键值等于key”的元素个数 |
find(key) |
返回”键值等于key”的第一个元素，找不到返回end |
lower_bound(key) |
返回”键值大于等于key”的第一个元素 |
upper_bound(key) |
返回”键值大于key”的第一个元素 |
equal_range(key) |
返回”键值等于key”的元素区间 |
5）迭代器相关函数
同容器
6）安插元素insert
c.insert(pos,e) |
在pos位置为起点插入e的副本，并返回新元素位置（插入速度取决于pos） |
c.insert(e) |
插入e的副本，并返回新元素位置 |
c.insert(beg,end) |
将区间[beg,end]内所有元素的副本插入到c中 |
7）移除元素
c.erase(pos) |
删除迭代器pos所指位置的元素，无返回值 |
c.erase(val) |
移除所有值为val的元素，返回移除元素个数 |
c.erase(beg,end) |
删除区间[beg,end]内所有元素，无返回值 |
c.clear() |
移除所有元素，清空容器 |
9.set/multiset
set中不允许key相同的元素，multiset允许key相同的元素
返回指向第一个元素的迭代器 |
|
清除所有元素 |
|
返回某个值元素的个数 |
|
如果集合为空，返回true |
|
返回指向最后一个元素的迭代器 |
|
返回集合中与给定值相等的上下限的两个迭代器 |
|
删除集合中的元素 |
|
返回一个指向被查找到元素的迭代器 |
|
返回集合的分配器 |
|
在集合中插入元素 |
|
返回指向大于（或等于）某值的第一个元素的迭代器 |
|
返回一个用于元素间值比较的函数 |
|
返回集合能容纳的元素的最大限值 |
|
返回指向集合中最后一个元素的反向迭代器 |
|
返回指向集合中第一个元素的反向迭代器 |
|
集合中元素的数目 |
|
交换两个集合变量 |
|
返回大于某个值元素的迭代器 |
|
返回一个用于比较元素间的值的函数 |
三．迭代器
* |
返回当前位置上的元素值。如果该元素有成员，可以通过迭代器以operator ->取用 |
++ |
将迭代器前进至下一元素 |
==和!= |
判断两个迭代器是否指向同一位置 |
= |
为迭代器赋值（将所指元素的位置赋值过去） |
2）所有容器都提供获得迭代器的函数
begin() |
返回一个迭代器，指向第一个元素 |
end() |
返回一个迭代器，指向最后一个元素之后 |
3）所有容器都提供两种迭代器
container::iterator以“读/写”模式遍历元素
container::const_iterator以“只读”模式遍历元素
4）迭代器分类
---双向迭代器
可以双向行进,以递增运算前进或以递减运算后退、可以用==和!=比较。
list、set和map提供双向迭代器
---随机存取迭代器
除了具备双向迭代器的所有属性，还具备随机访问能力。
可以对迭代器增加或减少一个偏移量、处理迭代器之间的距离或者使用<和>之类的关系运算符比较两个迭代器。
vector、deque和string提供随机存取迭代器
四．算法
泛型算法通则
所有算法的前两个参数都是一对iterators：[first，last)，用来指出容器内一个范围内的元素。
1.count
template<class InIt, class T>
size_t count(InIt first, InIt last, const T& val);
计算[first,last) 中等于val的元素个数
2.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的个数
3.min_element
template<class FwdIt>
FwdIt min_element(FwdIt first, FwdIt last);
返回[first,last) 中最小元素的迭代器,以“< ”作比较器
4.max_element
template<class FwdIt>
FwdIt max_element(FwdIt first, FwdIt last);
返回[first,last) 中最大(不小）元素的迭代器,以“< ”作比较器
5.for_each
template<class InIt, class Fun>
Fun for_each(InIt first, InIt last, Fun f);
对[first,last)中的每个元素 e ,执行 f(e) , 要求 f(e)不能改变e
6.find
template<class InIt, class T>
InIt find(InIt first, InIt last, const T& val);
返回区间 [first,last) 中的迭代器 i ,使得 * i == val
7. find_if
template<class InIt, class Pred>
InIt find_if(InIt first, InIt last, Pred pr);
返回区间 [first,last) 中的迭代器 i, 使得 pr(*i) == true
8.reverse
template<class BidIt>
void reverse(BidIt first, BidIt last);
颠倒区间[first,last)顺序
9.unique去重
template<class FwdIt>
FwdIt unique(FwdItfirst, FwdIt last);
用 == 比较是否相等
template<class FwdIt, class Pred>
FwdIt unique(FwdItfirst, FwdIt last, Pred pr);
用 pr 比较是否等
去除[first,last) 这个升序序列中的重复元素
返回值是迭代器，指向元素删除后的区间的最后一个元素的后面
例题
1
Vector<int> MyVec(100);//定义长度为100的向量
MyVec[50]=1024;//给向量某个元素赋值
int i=0;
for( ;i<25;i++)
{
MyVec,push_back(1);//向量末尾增加数值1
}
MyVec.resize(400);//重新定义向量长度为400
2
#include <iostream>
#include <map>
using namespace std;
ostream & operator <<( ostream & o,const pair< int,double> & p)
{
o << "(" << p.first << "," << p.second << ")";
return o;
}
int main() {
typedef map<int,double,less<int> > mmid;
mmid pairs;
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::iterator i;
cout << "3) ";
for( i = pairs.begin(); i != pairs.end();i ++ )
cout << * i << ",";
cout << endl;
cout << "4) ";
int n = pairs[40];//如果没有关键字为40的元素，则插入一个
for( i = pairs.begin(); i != pairs.end();i ++ )
cout << * i << ",";
cout << endl;
cout << "5) ";
pairs[15] = 6.28; //把关键字为15的元素值改成6.28
for( i = pairs.begin(); i != pairs.end();i ++ )
cout << * i << ",";
}
心得
STL包括很多数据结构和算法，虽然短时间内记忆起来有些难度（平时多用用），但是可以使编写程序的速度更快，印象最深的就是sort函数，之前学习的什么冒泡排序啊，快速排序啊，说实话学的一点都不好，甚至不大会用，很苦恼，但是sort函数完美的解决了这个问题，往往一条语句就解决了问题！所以说，STL是很有用的，能使我们的代码跟简洁，更快速。