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

简介

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

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_Unord;

    template <typename Key, typename T,
            typename Hash = hash<T>,
            typename EqPred = equal_to<T>,
            typename Allocator = allocator<pair<const Key, T> > >
        class unordered_multiUnord;
}

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

unordered_set、unodered_multiset结构

unordered_Unord、unodered_multiUnord结构

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() //销毁所有元素并释放内存

在这里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进行比较

布局操作

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) //设置桶最大负责数量为val

c.rehash(bnum) //重新生产哈希表，使桶的数目至少为bnum

c.reserve(num) //重新生产哈希表，以至于有足够的空间存放num个元素

非变动性操作

c.empty() //判断容器是否为空，与size()==0相同，但可能更快

c.size() //返回当前元素数量

c.max_size() //返回可容纳的元素最大数量

c1 == c2 //判断c1与c2是否相等

c1 != c2 //判断c1与c2是否不相等，等同于!(c1==c2)

特殊查询操作

c.count(val) //返回值为val的元素个数

c.find(val) //返回第一个值为val的位置，若没找到返回end()

c.equal_range(val) //返回所有元素值为val的范围，如val可以被插入的第一个位置到最后一个位置

赋值

c = c2 //将c2所有元素赋值给c

c = rv //将右值对象rv的所有元素移动赋值给c

c = initlist //使用初始化列表进行赋值

c1.swap(c2) //交换c1和c2的数

swap(c1,c2) //交换c1和c2的数

迭代器相关函数

c.begin() //返回一个前向迭代器，指向第一个元素

c.end() //返回一个前向迭代器，指向最后一个元素

c.cbegin() //返回一个前向常迭代器，指向第一个元素

c.cend() //返回一个前向常迭代器，指向最后一个元素

c.rbegin() //返回一个逆向迭代器，指向逆向迭代的第一个元素

c.rend() //返回一个逆向迭代器，指向逆向迭代的最后一个元素

c.crbegin() //返回一个逆向常迭代器，指向逆向迭代的第一个元素

c.crend() //返回一个逆向常迭代器，指向逆向迭代的最后一个元素

插入和移除元素

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

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桶内指向第一个元素的前向常迭代器

把unordered_map和unordered_multimap当作关联数组使用

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

c.at(key) //返回一个指向键值为key的元素的引用