STL学习笔记9— —无序容器（Unordered Container）

简介

在头文件<unordered_set>和<unordered_map> 中定义

namespace std {    template <typename T,            typename Hash = hash<T>,            typename EqPred = equal_to<T>,            typename Allocator = allocator<T> >        class unordered_set;    template <typename T,            typename Hash = hash<T>,            typename EqPred = equal_to<T>,            typename Allocator = allocator<T> >        class unordered_multiset;    template <typename Key, typename T,            typename Hash = hash<T>,            typename EqPred = equal_to<T>,            typename Allocator = allocator<pair<const Key, T> > >        class unordered_map;    template <typename Key, typename T,            typename Hash = hash<T>,            typename EqPred = equal_to<T>,            typename Allocator = allocator<pair<const Key, T> > >        class unordered_multimap;}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

unordered_set、unodered_multiset、unordered_map、unodered_multimap都是无序容器，都是以哈希表实现的。

unordered_set、unodered_multiset结构

unordered_map、unodered_multimap结构

Unord和multiUnord操作

构造、复制与析构

Unord c //默认构造函数；创建一个空无序容器Unord c(bnum) //创建一个空无序容器，内部至少使用了bnum个桶Unord c(bnum,hf) //创建一个空无序容器，内部至少使用了bnum个桶,hf作为哈希函数Unord c(bnum,hf,cmp) //创建一个空无序容器，内部至少使用了bnum个桶,hf作为哈希函数,cmp用来识别相等的值Unord c = c2 //复制构造函数；创建一个新的无序容器作为c2的副本（所有元素都被复制）Unord c = c2 //复制构造函数；创建一个新的无序容器作为c2的副本（所有元素都被复制）Unord c(rv) //移动构造函数；使用右值对象rv创建一个新无序容器Unord c = rv //移动构造函数；使用右值对象rv创建一个新无序容器Unord c(beg,end) //创建一个无序容器，并使用beg到end范围内的值进行初始化Unord c(beg,end,bnum) //创建一个无序容器，并使用beg到end范围内的值初始化，内部至少使用了bnum个桶Unord c(beg,end,bnum,hf) //创建一个无序容器，并使用beg到end范围内的值初始化，内部至少使用了bnum个桶,hf作为哈希函数Unord c(beg,end,bnum,hf,cmp) //创建一个无序容器，并使用beg到end范围内的值初始化，内部至少使用了bnum个桶,hf作为哈希函数,cmp用来识别相等的值Unord c(initlist) //创建一个无序容器，并使用初始化列表进行初始化Unord c = initlist //创建一个无序容器，并使用初始化列表进行初始化c.~Unord() //销毁所有元素并释放内存
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

在这里Unord可能是如下的一种：

unordered_set<Elem> //一个无序set，使用默认hash<>，默认比较equal_to<>unordered_set<Elem,Hash> //一个无序set，使用Hash作为hash函数，默认比较equal_to<>unordered_set<Elem,Hash,Cmp> //一个无序set，使用Hash作为hash函数，使用Cmp进行比较unordered_multiset<Elem> //一个无序multiset，使用默认hash<>，默认比较equal_to<>unordered_multiset<Elem,Hash> //一个无序multiset，使用Hash作为hash函数，默认比较equal_to<>unordered_multiset<Elem,Hash,Cmp> //一个无序multiset，使用Hash作为hash函数，使用Cmp进行比较unordered_map<Key,T> //一个无序map，使用默认hash<>，默认比较equal_to<>unordered_map<Key,T,Hash> //一个无序map，使用Hash作为hash函数，默认比较equal_to<>unordered_map<Key,T,Hash,Cmp> //一个无序map，使用Hash作为hash函数，使用Cmp进行比较unordered_multimap<Key,T> //一个无序multimap，使用默认hash<>，默认比较equal_to<>unordered_multimap<Key,T,Hash> //一个无序multimap，使用Hash作为hash函数，默认比较equal_to<>unordered_multimap<Key,T,Hash,Cmp> //一个无序multimap，使用Hash作为hash函数，使用Cmp进行比较
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

布局操作

c.hash_function() //返回哈希函数c.key_eq() //返回用于比较键的相等性的函数c.bucket_count() //返回目前桶的个数c.max_bucket_count() //返回桶的可能的最大数目c.load_factor() //返回目前桶内的负载的元素数量c.max_load_factor() //返回桶能够负载的最大元素数量c.max_load_factor(val) //设置桶最大负责数量为valc.rehash(bnum) //重新生产哈希表，使桶的数目至少为bnumc.reserve(num) //重新生产哈希表，以至于有足够的空间存放num个元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

非变动性操作

c.empty() //判断容器是否为空，与size()==0相同，但可能更快c.size() //返回当前元素数量c.max_size() //返回可容纳的元素最大数量c1 == c2 //判断c1与c2是否相等c1 != c2 //判断c1与c2是否不相等，等同于!(c1==c2)
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

特殊查询操作

c.count(key) //返回键值为key的元素个数c.find(key) //返回第一个键值为key的位置，若没找到返回end()c.equal_range(key) //返回所有键值为key的范围，如key可以被插入的第一个位置到最后一个位置
1
2
3
4
5
1
2
3
4
5

赋值

c = c2 //将c2所有元素赋值给cc = rv //将右值对象rv的所有元素移动赋值给cc = initlist //使用初始化列表进行赋值c1.swap(c2) //交换c1和c2的数swap(c1,c2) //交换c1和c2的数
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

迭代器相关函数

c.begin() //返回一个前向迭代器，指向第一个元素c.end() //返回一个前向迭代器，指向最后一个元素c.cbegin() //返回一个前向常迭代器，指向第一个元素c.cend() //返回一个前向常迭代器，指向最后一个元素c.rbegin() //返回一个逆向迭代器，指向逆向迭代的第一个元素c.rend() //返回一个逆向迭代器，指向逆向迭代的最后一个元素c.crbegin() //返回一个逆向常迭代器，指向逆向迭代的第一个元素c.crend() //返回一个逆向常迭代器，指向逆向迭代的最后一个元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

插入和移除元素

c.insert(val) //插入一个val的副本，返回新元素位置（对Unord来说不论成功与否）c.insert(pos,val) //插入一个val副本，返回新元素位置（pos应该是插入的搜寻起点）c.insert(beg,end) //将范围beg到end的所有元素的副本插入到c（无返回值）c.insert(initlist) //插入初始化列表的所有元素的副本（无返回值）c.emplace(args...) //插入一个使用args初始化的元素副本，返回新元素位置（对Unord来说不论成功与否）c.emplace_hint(pos,args...) //插入一个使用args初始化的元素副本，返回新元素位置（pos应该是插入的搜寻起点）c.erase(val) //移除所有与val值相等的元素，并返移除的元素个数c.erase(pos) //移除迭代器位置的元素，并返回下个元素的位置c.erase(beg,end) //移除beg到end范围内的所有元素，并返回下个元素的位置c.clear() //移除所以元素，清空容器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

bucket接口

c.bucket_count() //返回目前桶的个数c.bucket(val) //返回值val会被查询到的桶的索引c.bucket_size(buckidx) //返回buckidx桶内的元素个数c.begin(buckidx) //返回buckidx桶内指向第一个元素的前向迭代器c.end(buckidx) //返回buckidx桶内指向第一个元素的前向迭代器c.cbegin(buckidx) //返回buckidx桶内指向第一个元素的前向常迭代器c.cend(buckidx) //返回buckidx桶内指向第一个元素的前向常迭代器
1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6
7
8
9
10
11
12
13

把unordered_map当作关联数组使用

c[key] //返回一个指向键值为key的元素的引用，如果不存在就插入这个元素c.at(key) //返回一个指向键值为key的元素的引用
1
2
3
1
2
3