#include <set>
set,multiset
#include <map>
map,multimap
#include <unordered_map>
unordered_map,unordered_multimap
#include <unordered_set>
unordered_set,unordered_multiset
11.2 关联容器概述
关联容器不支持顺序容器的位置相关的操作，关联容器中根据关键字存储，不支持接受一个元素值和一个数量值的构造函数或插入操作。
关联容器的迭代器是双向的。
11.2.1 定义关联容器
map<string, size_t> word_count;//空容器
map<string, size_t> p(word_cout);
set<string> exclude = {"the","world","is","beautiful"};//列表初始化
map<string,string> authors = {{"Joyce","James"},{"Cao Dragon", "Cao"},{"Good","Job"}};
{key,value}//键值对
set<int> iset(v.cbegin(), v.cend());//不可有重复关键字
multiset<int> miset(v.cbegin(), v.cend());//可以有重复关键字
11.2.2 关键字类型的要求
对于有序关联容器，关键字类型必须定义元素比较的方法，默认情况为<运算符；传递给排序算法的可调用对象必须满足于关联容器中关键字一样的类型要求。
自定义的比较操作（针对关键字类型），严格弱序，即“小于等于”。
1，两个关键字不可以同时“小于等于”对方
2，有传递性
3，如果两个关键字都不“小于等于”对方，称为关键字等价，容器视之为相等来处理
multiset<T, decltype(func)*> object(func);//自定义了比较函数，传入了一个函数指针
11.2.3 pair类型
pair的数据成员是public，分别为first， second
#include <utility>
pair<T1, T2> p;//进行了值初始化
pair<T1, T2> p(v1, v2);//first和second成员分别用v1，v2初始化
pair<T1, T2> p = {v1, v2};//等价上一个
pair<T1, T2> p{v1, v2};//等价上一个
make_pair<v1, v2>;//返回一个用v1 v2初始化的pair。pair的类型从v1 v2的类型中推断出来
p.first, p.second;//返回数据成员
p1 relop p2;//relop关系运算符，先比较first,若相等再比较second，使用元素的<比较
p1 == p2;
p1 != p2;//使用元素的==比较，当first和second分别相等时pair相等
pair<string, int> pro(vector<string> &v){
if (!v.empty())
return {v.back(), v.back().size()};//列表初始化
else
return pair<string, int>();//隐式构造返回值
}
11.3 关联容器的操作
类型别名
1，key_type ；关键自类型
2，mapped_type；关键字关联的类型，适用于map
3，value_type；值类型，对于set与key_type相同，对于map为pair<const key_type，mapped_type>
11.3.1 关联容器迭代器
解引用一个关联容器迭代器，返回一个value_type类型的对象的引用；迭代器按关键字升序遍历
auto map_it = word_count.begin();
map_it->first; map_it->second;
set的迭代器只有访问权限，是const的；set<string>::iterator 和set<string>::const_iterator都不可改变set元素的值。
11.3.2 添加元素
word_count.insert({"hehe", 1});
word_count.insert(make_pair(word, 1));
word_count.insert(pair<string, size_t>(word, 1));
word_count.insert(map<string, size_t>::value_type(word,1));
c.insert(v);
c.emplace(args);//v是value_type类型的对象；args用来构造一个元素。对于map和set，当关键字不在c中才插入（构造）元素；返回一个pair，first为一个迭代器指向插入的关键字，second指示是否插入成功bool型
c.insert(b,e);//
c.insert(li);//b,e为c::value_type类型的值的范围；li为初始值列表；返回void
c.insert(p, v);//
c.emplace(p,args);//表示从c的p位置开始搜索应该插入哪儿，返回一个迭代器，指向具有给定关键字的元素
11.3.3 删除元素
c.erase(k);//从c中删除所有关键字为k的元素，返回size_type值，删除元素的数量
c.erase(p);//从c中删除p指定的一个真实元素，返回此元素的后一个元素的迭代器
c.erase(b, e);//删除迭代器范围内的值，返回e
11.3.4 map的下标操作
map,unordered_map支持的下标操作
返回左值
c[k];//返回关键字k的元素；如果k不在c中，添加关键字为k的元素，进行值初始化
c.at(k);//访问关键字为k的元素，带参数检查；若k不在c中，抛出out_of_range异常
下标操作得到mapped_type类型的对象，解引用map的迭代器，得到value_type类型的对象
11.3.5 访问元素
lower_bound和upper_bound不适用与无序容器
下标和at操作只适用于非const的map和unordered_map
c.find(k);//返回一个指向关键字为k的元素，若k不在容器中，则返回尾后迭代器
c.count(k);//返回关键字为k的元素的数量
c.lower_bound(k);//返回指向第一个不小于k的元素的迭代器
c.upper_bound(k);//返回指向第一个大于k的元素的迭代器
c.equal_range(k);//返回一个迭代器pair，表示关键字等于k的元素的范围，若k不存在，pair的两个成员均等于c.end()
11.4 无序容器
使用哈希函数和关键字类型==运算符来组织元素
无序容器在存储上组织为一组桶，每个桶保存零个或多个元素。将元素使用哈希函数映射到桶。
无序容器管理操作
桶接口
c.bucket_count();//正在使用的桶数目
c.max_bucket_count();//桶数目的上限
c.bucket_size(n);//第n个桶中的元素个数
c.bucket(k);//关键字为k的元素在哪个桶中
桶迭代
local_iterator,const_local_iterator 访问桶中元素的迭代器类型
c.begin(),c.end(),c.cbegin(),c.cend()
哈希策略
c.load_factor();//每个桶的平均元素数量，float
c.max_load_factor();//c试图维护的平均桶大小，返回float，会在需要的时候添加新的桶，使得load_factor<=max_load_factor
c.rehash(n);//重组存储，使bucket_count>=n,且bucket_count>size/max_load_factor
c.reserve(n);//重组存储，使得c可以保存n个元素切不必rehash
内置类型，指针，string，智能指针定义了hash模板，使用hash<key_type>类型的对象来生成每个元素的哈希值；自定义类型必须提供自己的hash模板
例：
size_t hasher(const Sales_data &sd){
return hash<string>()(sd.isbn());
}
bool eqOp(const Sales_data &lhs, const Sales_data &rhs){
return lhs.isbn() == rhs.isbn();
}
using SD_multiset = unordered_multiset<Sales_data, decltype(hasher)*, decltype(eqOp)*>;
Sd_multiset bookstore(42, hasher, eqOp);
若类定义了==运算符，则可值重载哈希函数
