简单介绍

在头文件<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;
}

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

在这里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(key) //返回键值为key的元素个数

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

c.equal_range(key) //返回全部键值为key的范围。如key可以被插入的第一个位置到最后一个位置

赋值

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当作关联数组使用

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

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