标准模板库--STL

简介：
STL是C++标准程序库的核心，深刻影响了标准程序库的整体结构
STL由一些可适应不同需求的集合类（collection class），以及在这些数据集合上操作的算法（algorithm）构成
STL内的所有组件都由模板（template）构成，其元素可以是任意类型
STL是所有C++编译器和所有操作系统平台都支持的一种库
**STL组件：**容器，迭代器，算法，容器适配器，函数对象。
STL容器
STL容器就是将运用最广泛的一些数据结构实现出来
常用的数据结构： 数组, 链表,树, 栈, 队列, 集合, 映射表 等
这些容器分为序列式容器和关联式容器两种:
==​序列式容器:==强调值的排序，序列式容器中的每个元素均有固定的位置。
==关联式容器:==二叉树结构，各元素之间没有严格的物理上的顺序关系。
STL容器元素条件：
1.必须能够通过拷贝构造函数进行复制；
2.必须可以通过赋值运算符完成赋值操作；
3.必须可以通过析构函数完成销毁动作；
4.序列式容器元素的默认构造函数必须可用；
5.某些动作必须定义operator =，例如搜寻操作；
6.关联式容器必须定义出排序准则，默认情况是重载operator <。
注：STL容器的共同操作：
size() 返回当前容器的元素数量
empty() 判断容器是否为空
max_size() 返回容器能容纳的最大元素数量
== ，!= , < , <= , > , >=
函数：
swap() 交换 用于提高赋值操作效率
begin() 返回一个迭代器，指向第一个元素
end() 返回一个迭代器，指向最后一个元素之后
rbegin() 返回一个逆向迭代器，指向逆向遍历的第一个元素
rend() 返回一个逆向迭代器，指向逆向遍历的最后一个元素之后
insert(pos,e) 将元素e的拷贝安插与迭代器pos所指的位置
erase(beg,end) 移除[beg,end]区间内的所有元素
clear() 移除所有元素

迭代器

可遍历STL容器内全部或部分元素的对象，指出容器中的一个特定位置
一些基本操作：
*：返回当前位置上的元素值。如果该元素有成员，可通迭代器以operator->取用
++：将迭代器前进至下一元素
和！= ：判断两个迭代器是否指向同一位置
=：为迭代器赋值。
begin() 返回一个迭代器，指向第一个元素
end() 返回一个迭代器，指向最后一个元素之后
双向迭代器：
1.可以双向行进,以递增运算前进或以递减运算后退、可以用和!=比较。
2.list、set和map提供双向迭代器
随机存取迭代器
3.除了具备双向迭代器的所有属性，还具备随机访问能力。
4.可以对迭代器增加或减少一个偏移量、处理迭代器之间的距离或者使用<和>之类的关系运算符比较两个迭代器。
5.vector、deque和string提供随机存取迭代器
例如：

#include <bits/stdc++.h>
using namespace std;

int main()
{
	vector<string> str;
	vector<string>::iterator sit;
	string s;
	cin>>s;
	while(s!="#")
	{
		str.push_back(s);
		cin>>s;
	}
	for(sit=str.begin();sit!=str.end();sit++)
		cout<<(*sit)<<" ";
	cout<<endl;
	system("pause");
	return 0;
}

vector

vector的元素可以是任意类型T，但必须具备赋值和拷贝能力（具有public拷贝构造函数和重载的赋值操作符）,必须包含的头文件#include
1.size返回实际元素个数，
2.capacity返回vector能容纳的元素最大数量。如果插入元素时，元素个数超过capacity，需要重新配置内部存储器。
操作：
vectorc 产生空的vecto
vectorc1(c2) 产生同类型的c1，并复制c2的所有元素
vectorc(n) 利用类型T的默认构造函数和拷贝构造函数生成一个大小为n的vector
vectorc(n,e) 产生一个大小为n的vector,每个元素都是e
vectorc(beg,end)产生一个vextor,以区间[beg,end]为元素初值
vector（）销毁所有元素并释放内存
c.size() 返回元素个数
c.empty() 判断容器是否为空
c.max_size()返回元素最大可能的数量
c.capacity()返回重新分配空间前可容纳的最大元素数量
c.reserve(n)扩大容量n
c1=c2 c2的全部元素赋值给c1
c.assign(n.e) 将元素e的n个拷贝赋值给c
c1.swap(c1,c2)元素互换
at(idx)返回索引idx所标识的元素的引用，进行越界检查
operator返回索引idx所标识的元素的引用，不进行越界检查
front()返回第一个元素的引用，不检查元素是否存在
back()返回最后一个元素的引用，不检查元素是否存在
begin()返回一个迭代器，指向第一个元素
end()返回一个迭代器，指向最后一个元素
rbegin()返回一个逆向迭代器，指向逆向遍历的第一个元素
rend()返回一个逆向迭代器，指向逆向遍历的最后一个元素
c.insert(pos,e)在pos位置插入元素e的副本
c.insert(pos,n,e)在pos位置插入n个元素e的副本
c.push_back(e)在pos位置插入区间[beg,end]内所有元素的副本
c.pop_back()在尾部添加一个元素e的副本
c.erase(pos)删除pos位置的元素，返回下一个元素的位置
c.erase(beg,end)删除区间[beg,end]内所有元素，返回下一个元素的位置
c.clear（）移除所有的元素，清空容器
c.resize(num,e)将元素数量改为num(增加的元素是e的副本

#include <bits/stdc++.h>
using namespace std;
int main()
{
	vector<string> str;
	vector<string>::iterator sit;
	string s;
	cin>>s;
	while(s!="#")
	{
		str.push_back(s);
		cin>>s;
	}
	for(sit=str.begin();sit!=str.end();sit++)
		cout<<(*sit)<<" ";
	cout<<endl;
	vector<string> str1(str);
	cout<<str1.size()<<endl;
	if(str1.empty())
        cout<<"NULL"<<endl;
    cout<<str1.max_size()<<endl;
    cout<<"是否相同"<<(str==str1)<<endl;
    int n;
    cin>>n;
    c.reserve(n);
    cout<<str1.max_size()<<endl;
    system("pause");
	return 0;
}

map/multimap

1使用平衡二叉树管理元素
2元素包含两个部分（key，value），key和value可以是任意类型
3必须包含的头文件#include
4根据元素的key自动对元素排序，因此根据元素的key进行定位很快，但根据元素的value定位很慢
不能直接改变元素的key，可以通过operator[]直接存取元素值
5map中不允许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<key,value>  //以less(<)为排序准则的map
map<key,value,op>  //以op为排序准则的map

同vector相同map同样有以下操作

//**非变动性操作**
map<key,value> c;
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)   //同上，全局函数

特殊搜索操作`

count(key)   //返回“键值等于key”的元素个数
find(key)     //返回“键值等于key”的第一个元素，找不到返回end
lower_bound(key)   //返回“键值大于等于key”的第一个元素
upper_bound(key)   //返回“键值大于key”的第一个元素
equal_range(key)   //返回“键值等于key”的元素区间

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()   //移除所有元素，清空容器

#include <bits/stdc++.h>
using namespace std;

class Student
{
private:
    string id;
    string name;
    string grade;
public:
    Student(){};
    Student(string id):id(id){};
    string getId(){return id;};
    friend istream & operator >>(istream &in,Student &s)
    {
        in>>s.name>>s.grade;
        return in;
    }
    friend ostream & operator <<(ostream &out,Student &s)
    {
        out<<s.id<<" "<<s.name<<" "<<s.grade<<endl;
        return out;
    }
};
int main()
{
    vector<Student> student;
    multimap<string,int> studentid;
    string id;
    cin>>id;
    while(id!="#")
    {
        Student s(id);
        cin>>s;
        student.push_back(s);
        studentid.insert(make_pair(s.getId(),student.size()-1));
        cin>>id;
    }
    vector<Student>::iterator sit;
    multimap<string,int>::iterator it;
    cin>>id;
    it=studentid.find(id);
    if(it!=studentid.end())
        cout<<student[it->second];
    for(sit=student.begin();sit!=student.end();sit++)
        cout<<(*sit);
        system("pause");
    return 0;
}

set/multiset
使用平衡二叉树管理元素
集合（set）是一种包含已排序对象的关联容器
必须包含的头文件#include
map容器容器是键-值对的集合，好比以人名为键的地址和电话号码。相反地，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()    //返回一个用于比较元素间的值的函数

Algorithm（算法）

泛型算法通则
所有算法的前两个参数都是一对iterators：[first，last)，用来指出容器内一个范围内的元素。
每个算法的声明中，都表现出它所需要的最低层次的iterator类型。
count：
size_t count(InIt first, InIt last, const T& 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
FwdIt min_element(FwdIt first, FwdIt last);
返回[first,last) 中最小元素的迭代器,以 “< ”作比较器
max_element:
template
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 <bits/stdc++.h>
using namespace std;

class CLessThen9
{
public:
    bool operator()(int n)
    {
        return n<9;
    }
};
void outputSquare(int value)
{
    cout<<value*value<<" ";
}
int main()
{
    int a[10]={124,45,88,186,76,185,65,34,15,94};
    vector<int> v(a,a+10);
    ostream_iterator<int> output(cout," ");
    cout<<endl;
    cout<<count(v.begin(),v.end(),88)<<endl;
    cout<<count_if(v.begin(),v.end(),CLessThen9())<<endl;
    cout<<*(min_element(v.begin(),v.end()))<<endl;
    cout<<*max_element(v.begin(),v.end())<<endl;
    for_each(v.begin(),v.end(),outputSquare);
}

find
template<class InIt, class T>
InIt find(InIt first, InIt last, const T& val);
返回区间 [first,last) 中的迭代器 i ,使得 * i == val

find_if
template<class InIt, class Pred>
InIt find_if(InIt first, InIt last, Pred pr);
返回区间 [first,last) 中的迭代器 i, 使得 pr(*i) == true
binary_search
折半查找，要求容器已经有序且支持随机访问迭代器，返回是否找到

template<class FwdIt, class T>
 bool binary_search(FwdIt first, FwdIt last, const T& val); 
//上面这个版本，比较两个元素x,y 大小时, 看 x < y

template<class FwdIt, class T, class Pred> 
bool binary_search(FwdIt first, FwdIt last, const T& val, Pred pr); 
//上面这个版本，比较两个元素x,y 大小时, 看 pr(x,y)

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 大
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) 这个升序序列中的重复元素
//返回值是迭代器，指向元素删除后的区间的最后一个元素的后面