STL总结

STL由一些可适应不同需求的集合类以及在这些数据集合上操作的算法构成。
STL内的元素可以是任意类型。
STL组件的联系：

STL中存放的都是值而非引用。
STL容器的共同操作：
1.初始化：
（1）产生一个空容器：
std::list<int> l;
(2)以另一个容器元素为储值完成初始化：

std::list<int> l;
...
std::vector<float> c(l.begin(),l.end());

begin():返回一个迭代器，指向第一个元素。
end():返回一个迭代器，指向最后一个元素之后。

（3）以数组元素为初值完成初始化

int array[]={2,4,6,1345};
...
std::set<int> c(array,array+sizeof(array)/sizeof(array[0]));

2.与大小相关的操作
size()：返回当前容器的元素数量
empty()：判断容器是否为空
max_size()：返回容器能容纳的最大元素数量
3.与迭代器相关的操作
begin():返回一个迭代器，指向第一个元素。
end():返回一个迭代器，指向最后一个元素之后。
rbegin()：返回一个逆向迭代器，指向逆向遍历的第一个元素。
rend()：返回一个逆向迭代器，指向逆向遍历最后一个元素之后。
4.元素操作
insert（pos,e)：将元素e的拷贝安插于迭代器pos所指的位置
erase(beg,end)：移除[beg,end]区间内的所有元素
clear（）：移除所有元素
迭代器：可遍历STL容器内全部或部分元素的对象；指出容器中的一个特定位置
container::iterator——以“读/写”模式遍历元素
container::const_iterator——以“只读”模式遍历元素
迭代器分类：
（1）双向迭代器：

list<int> l;
for(pos=l.begin();pos!=l.end();++pos){
...
}

list，set和map提供双向迭代器
（2）随机存取迭代器

list<int> v;
for(pos=v.begin();pos<v.end();++pos){
...
}

vector，deque和string提供随机存取迭代器
**vector：**模拟动态数组，支持随机存取
必须包含的头文件#include<vector>
主要方法：
empty() //判断容器是否为空，与size()==0相同
size() //返回当前元素数量
max_size() //返回可容纳的元素最大数量
capacity() //返回在不重新分配的情况下可容纳的元素的最大数量 reserve(n) //扩大容量为n
c.push_back(e) //在末尾添加一个e副本
c.pop_back() //移除末尾元素但不返回最后一个元素
c.insert(pos,e) //在迭代器位置前面插入一个e副本，并返回新元素的位置
c.resize(num) //将元素数量设为num（如果size()增大，多出来的元素使用默认构造函数创建）
c.resize(num,elem) //将元素数量设为num（如果size()增大，多出来的元素都是elem的副本）
c.clear() //移除所以元素，清空容器

#include<iostream>
#include<vector>
int main(){
vector<int> a;
for(int i=0;i<5;++i){
a.push_back(5-i);
}
cout<<a.size()<<endl;
a.pop_back();//移除最后一个元素但不返回最后一个元素
a[0]=1;
cout<<a.size()<<endl;
for(int j=0;j<(int)a.size();j++){//依次输出元素
cout<<a[j]<<" ";
}
cout<<endl;
sort(a.begin(),a.end());
for(int k=0;k<(int)a.size();k++){
cout<<a[k]<<" "<<;
}
cout<<endl;
a.clear();//清除所有元素
cout<<"Size:"<<a.size()<<endl;
return 0;
}

map/multimap:map容器是键-值对的集合，元素包含两部分（key，value），根据元素的key自动对元素排序，因此根据元素key进行定位很快。
必须包含的头文件#include<map>
map中不允许key相同的元素，multimap中允许key相同的元素
主要方法：

c.empty() //判断容器是否为空 c.size()//返回当前元素数量 c.max_size() //返回可容纳的元素最大数量 c.count(key) //返回键值为key的元素个数 c.find(key) //返回第一个键值为key的位置，若没找到返回end() c.lower_bound(key) //返回键值 >= key的第一个元素位置 c.upper_bound(key) //返回键值 > key的第一个元素位置 c.equal_range(key) //返回键值=key的元素区间
c.insert(val) //插入一个val的副本，返回新元素位置
c.insert(pos,val) //插入一个val副本，返回新元素位置
c.erase(val) //移除所有与val值相等的元素，并返移除的元素个数 c.erase(pos) //移除迭代器位置的元素，并返回下个元素的位置 c.erase(beg,end) //移除beg到end范围内的所有元素，并返回下个元素的位置
c.clear() //移除所以元素，清空容器

#include<iostream>
#include<map>
int main(){
map<string,int> m2;
map<string,int>::iterator m2i,p1;
m2["abd"]=2;//可以根据operator[]直接存取元素值
m2["abc"]=1;
m2["cba"]=2;
m2.insert(make_pair("aaa",9));//利用make_pair()直接插入键和值
m2["abf"]=4;
m2["abe"]=2;
cout<<m2["abc"]<<endl;
m2i=ma.find("cba");//返回键值等于key的第一个元素
if(m2i!=m2.end(){
cout<<m2i->first<<":"<<m2i->second<<endl;//m2i->first:键存储的数据；m2i->second:值存储的数据
}else{
cout<<"find nothing"<<endl;
}
for(p1=m2.begin();p1!=m2.end();p1++){
cout<<p1->first<<":"<<p1->second<<endl;
}
}

multimap:

#include<iostream>
#include<map>
int main(){
multimap<string,int> mm1;
multimap<string,int>::iterator mm1i,p1,p2;
mm1.insert(make_pair("b",3);//插入键-值对
mm1.insert(make_pair("a",0);
mm1.insert(make_pair("b",5);
mm1.insert(make_pair("c",4);
mm1.insert(make_pair("b",2);
cout<<mm1.size()<<endl;
for(mm1i=mm1.begin();mm1i!=mm1.end();mm1i++){
cout<<mm1i->first<<":"<<mm1i->second<<endl;
}
cout<<"Count:"<<mm1.count("b")<<endl;
p1=mm1.lower_bound("b");//返回键值大于等于key的第一个元素
p2=mm1.upper_bound("b");//返回键值大于key的第一个元素
for(mm1i=p1;mm1i!=p2;mm1i++){
cout<<mm1i->first<<":"<<mm1i->second<<endl;
}
return 0;
}

也可以将vector和map/multimap结合起来使用。例如：图书馆管理系统的操作类中可以将vector与map结合起来使用。vector中存储图书类，map中key为图书的书号，value为图书在vector中存储的位置，可以使操作更加简洁，编写程序时更加方便。

class Operation{
private:
    vector<Book> b;
    map<string,int> m1;
public:
     Operation(){}
     void addBook(){
      Book book;
      cin>>book;
    b.push_back(book);
    m1.insert(make_pair(book.getbookcode(),b.size()-1));
  }

set/multiset：
必须包含的头文件#include<set>
集合（Set)是一种包含已排列对象的关联容器。
set容器只是单纯的键的集合。
set中不允许key相同的元素，multiset中允许key相同的元素
主要方法：
begin()//返回指向第一个元素的迭代器
clear()//清除所有元素
count()//返回某个值元素的个数
empty()//如果集合为空，返回true
end(//返回指向最后一个元素的迭代器
equal range()//返回集合中与给定值相等的上下限的两个迭代器
erase(）//删除集合中的元素
find()//返回一个指向被查找到元素的迭代器
get allocator()//返回集合的分配器
insert()//在集合中插入元素
lower_ bound()//返回指向大于(或等于)某值的第-个元素的迭代器
key comp()//返回一个用于元素间值比较的函数
max_ size()//返回集合能容纳的元素的最大限值
rbegin(）//返回指向集合中最后-个元素的反向迭代器
rend(）//返回指向集合中第一个元素的反向迭代器
size()//集合中元素的数目
swap(）//交换两个集合变量
upper bound(）//返回大于某个值元素的迭代器.
value_ comp()//返回一个用于比较元素间的值的函数

struct T1{
int key;
int v1,v2;
bool operator<(const T1&b) const{
return (key<b.key);
}
};
struct T2{
int key;
int v1,v2;
};
struct T2cmp{
bool operator() const(const T2&a,const T2&b){
return (a.key<b.key);
}
};

set:

int main(){
set<T1> s2;
set< <T2, T2cmp> s3;
#if 1
set<string>s1;
set<string> ::iterator iter1;
#else
set<string, greater<string> >s1;
set<string, greater<string> >::iterator iter1;
#endif
s1.insert("abc");//插入
s1.insert("abc");
s1.insert("abc");
s1.insert("bca"); .
s1.insert("aaa");
cout << "ITERATE:" << endl;
for(iter1=s1.begin();iter1!=s1.end();iter1++){//输出各个元素
cout<<(*iter1)<<endl;
cout<<"FIND:"<<endl;
iter1=s1.find("abc");//返回一个指向被查找到元素的迭代器
if(iter1!=s1.endO){
cout<<*iter1<<endl;
}else{
cout<<"NOT FOUND"<<endl;
return 0;
}

multiset：

int main(){
multiset<T1> s2;
multiset <T2, T2cmp> s3;
#if 1
multiset<string>s1;
multiset <string>::iterator iter1;
#else
multiset<string,greater<string> >s1;
multiset<string,greater<string> > ::iterator iterl;
#endif
s1.insert("abc");
s1.insert("abc");
s1.insert("abc");
s1.insert("bca");
s1.insert("aaa");
cout<<"ITERATE:"<<endl;
for(iter1=s1.begin();iter1!=s1.end();iter1++)
cout<<*iter1<<endl;
cout<<"FIND:"<<endl;
iter1=s1.find("abc");
if(iter1!= s1.end())
cout<<*iter1<<endl;
else
cout<<"NOT FOUND"<<endl;
cout<<s1.count("abc")<<endl;
multiset<string>::iterator s1i,p1,p2;
p1=s1.lower_ bound("abc");
p2=s1.upper_ bound("abc");
for(s1i=p1;s1i!=p2;s1i++){ .
cout<<*s1i<<endl;
return 0; .
}

pair模板：
pair模板可以用于生成key-value对

#include<iostream>
#include<map>
using namespace std;
ostream & operator<<( ostream & o,const pair<int,double> & p){o
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<<",";
}

算法：
count
size_ t count( InIt first, Inlt last, constT& val);
计算[first,last)中等于val的元素个数.
count if
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 .

#include <vector>
#include <iostream>
#include <numeric>
#include <list>
#include <algorithm>
using namespace std;
class CLessThen9{
public:
bool operator()(int n){ return n<9;}
};
void outputSquare(int value){ cout << value*value <<" ";}
}
main( {
输出:
const int SIZE= 10;
int a1[]= {100,2,8,1,50,3,8,9,10,2 };
vector<int> v(a1,a1+SIZE);
ostream_iterator<int> output(cout," ");
cout << endl << "2) ";
cout<<count(v.begin(),v.end(),8);，//v中等于8的元素个数
cout<<endl<<"3)";
cout<<count_ if(v.begin(),v.end(),CLessThen9());//v中小于9的元素个数
cout<< endl<<"4) ";
cout<<*(min_element(v.begin(),v.end()));//v中最小的元素
cout<<endl<<"5) ";
cout<<*(max_element(v.begin(),v.end()));//v中最大的元素
cout<<endl<<"7) ";
for_each(v.begin(),v.end(),outputSquare);//v中每个元素的平方值

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(FwdIt first, FwdIt last, const T& val);
比较两个元素x,y大小时，看x<y

#include <vector>
#include <bitset>
#include <iostream>
#include <numeric>
#include <list>
#include <algorithm>
using namespace std;
bool Greater10(int n)
{
return n>10;
}
int main(){
const int SIZE=10;
inta1[]={2,8,1,50,3,100,8,9,10,2};
vector<int> v(a1,a1+SIZE);
ostream_iterator<int> output(cout," ");
vector<int>::iterator location;
location=find(v.begin(),v.end(),10);
if(location!=v.end()) {
cout<<endl<<"1) "<<location-v.begin();//10所在的元素位置
location=find_if(v.begin(),v.end(),Greater10);
if(location!=v.end())
cout<<endl<<"2) "<<location-v.begin();//大于10的第一个元素位置
sort(v.begin(),v.end());
if(binary_ search(v.begin(),v.end(),9)){//查找9是否存在
cout<<endl<<"3) "<<"9 found";
}
}

4)lower_ bound,uper bound, equal_ range
lower bound :
template<class FwdIt, class T> FwdIt lower_ bound(FwdIt first, FwdIt last, const T& val);
要求first,last)是有序的,查找大于等于val的最小的位置
upper_ bound：
template<class FwdIt, class T> FwdIt upper_ bound(FwdIt first, FwdIt last, const T& val);
要求[first,last)是有序的,查找大于val的最小位置
equal range：
template<class FwdIt, class T> pair<FwdIt, FwdIt> equal_ range(FwdIt first, FwdIt last, const T& val); .
要求[first,last)是有序的，返回值是一 个pair,假设为p,则[first,p.first)中的元素都比val小，[p.second,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
改变序列的算法：unique
template<class FwdIt> FwdIt unique(FwdIt first, FwdIt last);
用==比较是否相等
template<class FwdIt, class Pred> FwdIt unique(FwdIt first, FwdIt last, Pred pr);
用pr比较是否等于去除[first,last)这个升序序列中的重复元素，返回值是迭代器，指向元素删除后的区间的最后一个元素的后面
reverse
template<class BidIt> void reverse( BidIt first, BidIt last);
颠倒区间[first,last)顺序
感想：
STL在很大程度上为我们的编程提供了简便的方法，不用像链表和数组那样插曲删除元素时要编写很长一段代码来实现，只需要调用一个简单的方法即可完成插入删除等操作，大大提高了我们的效率。虽然STL比之前学习的几种方法简单的多，但是还是会有困惑的地方，问题总会一个一个冒出来，需要一一解决，不能看到问题就退缩，生疏的方法多练几遍就能变得熟练，困惑的地方需要积极寻找资料或向同学请教，这几点我也正在努力中，在以后的学习中要用行动践行，在以后编写程序的过程中也不能只图方便每次都使用STL，也要注重其他方法的使用，做到全面掌握。