STL教程(九): 关联容器--unordered_set/unordered_multiset

 一、unordered_set/unordered_multiset简介

template<
    class Key,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>,
    class Allocator = std::allocator<Key>
> class unordered_multiset;

参数介绍：

• Key：元素的类型，即类型为unordered_multiset::key_type或unordered_multiset::value_type。
• Hash：一元函数对象类型，它将与元素类型相同的对象作为参数，并基于它返回一个size_t类型的唯一值。默认为hash <Key>，它返回一个哈希值，容器对象使用此函数返回 的哈希值在内部组织其元素，从而加快定位单个元素的过程，其碰撞概率接近1.0/std::numeric_limits<size_t>::max()。类型为unordered_multiset::hasher
• KeyEqual：一个二元谓词，它接受两个与元素类型相同的参数并返回一个bool。容器使用此表达式来确定两个元素键是否等效。类型为unordered_multiset::key_equal
• Allocator：用于定义存储分配模型的分配器对象的类型。默认使用分配器类模板，它定义了最简单的内存分配模型，并且与值无关。类型为unordered_multiset::allocator_type。

unordered_multiset是一个不按特定顺序存储元素的容器，底层实现为哈希表，允许根据值快速检索单个元素，唯一和unordered_set不同的是，unordered_multiset允许同时存在多个相同的键值元素。在内部，unordered_multiset中的元素没有任何特定的排序，而是根据元素的哈希值组织成桶，以允许通过它们的值直接快速访问各个元素（平均具有恒定的平均时间复杂度）。

存储桶是容器内部哈希表中的一个槽，元素根据其哈希值分配给该槽。
桶的数量直接影响容器哈希表的负载因子（从而影响碰撞的概率）。容器会自动增加桶的数量以将负载因子保持在特定阈值（其max_load_factor）以下，每次需要增加桶的数量时都会导致重新散列。

二、unordered_set/unordered_multiset的成员函数

unordered_multiset的成员函数与unordered_set完全相同，下面以unordered_multiset为例进行介绍：

1、构造函数

（1）构造一个空的unordered_multiset容器，不包含任何元素且大小为零，也是默认构造函数

explicit unordered_multiset ( size_type n = /* see below */,
                              const hasher& hf = hasher(),
                              const key_equal& eql = key_equal(),
                              const allocator_type& alloc = allocator_type() );
explicit unordered_multiset ( const allocator_type& alloc );

（2）构造一个包含了范围[first,last)元素的unordered_multiset容器，每个元素都从该范围内的相应元素以相同的顺序就地构造。

template <class InputIterator>
    unordered_multiset ( InputIterator first, InputIterator last,
        size_type n = /* see below */,
        const hasher& hf = hasher(),
        const key_equal& eql = key_equal(),
        const allocator_type& alloc = allocator_type() );

（3） 以unordered_multiset容器x作为数据源，构造一个新unordered_multiset容器，其中新unordered_multiset容器中的元素来自于x中元素拷贝的副本。

unordered_multiset ( const unordered_multiset& ums ); 
unordered_multiset ( const unordered_multiset& ums, const allocator_type& alloc );

（4）该对象获取右值ums的内容

unordered_multiset (unordered_multiset&& ums); 
unordered_multiset (unordered_multiset&& ums, const allocator_type& alloc);

（5）用列表的内容初始化容器

unordered_multiset ( initializer_list<value_type> il, 
                     size_type n = /* 见下文 */, 
                     const hasher& hf = hasher(), 
                     const key_equal& eql = key_equal(), 
                     const allocator_type& alloc = allocator_type() );

注：上述函数中的变量n表示的是：容器初始存储桶的最小数量。这不是容器中元素的数量，而是构建时内部哈希表所需的最小槽数。如果未指定此参数，则构造函数会自动确定（以取决于特定库实现的方式）。类型为size_type是无符号整数类型。

2、operator=函数

（1）使用unordered_multiset列表other对其进行复制拷贝

unordered_multiset& operator=( const unordered_multiset& other );

（2）使用unordered_multiset列表other对其进行移动拷贝，之后other的数据将被清空

unordered_multiset& operator=( unordered_multiset&& other );

（3）使用初始化列表对unordered_multiset进行赋值

unordered_multiset& operator=( std::initializer_list<T> l );

3、迭代器

iterator begin() ;// 返回容器的迭代器到第一个元素
local_iterator begin ( size_type n );// 返回容器中桶序号为n的第一个元素迭代器

iterator end();    // 返回容器的迭代器到最后一个元素的后一个位置 
local_iterator end(size_type n);// 返回容器容器中桶序号为n的迭代器到最后一个元素的后一个位置 

const_iterator cbegin(); // 返回容器的迭代器到第一个元素
const_local_iterator cbegin ( size_type n );// 返回容器中桶序号为n的第一个元素迭代器

const_iterator cend();   // 返回容器的迭代器到最后一个元素
const_local_iterator cend(size_type n);// 返回容器容器中桶序号为n的迭代器到最后一个元素的后一个位置 

4、容量相关

bool empty(); // 判断容器是否为空
size_type size();// 返回容器中当前元素个数
size_type max_size(); //返回容器内可存放的最大元素个数,由系统或库实现进行限制，这是容器可以容纳的最大潜在元素数量。

5、修改容器

/* 向容器内插入一个元素，返回一个pair，其成员pair::first设置为一个迭代器，指向新插入的元素或已存在在set 中的元素。如果插入成功，则pair::second元素为true，若该元素已存在，则为false */
pair<iterator,bool> insert (const value_type& val);
pair<iterator,bool> insert (value_type&& val);

// 尽量靠近position位置插入新元素val，并返回新元素位置或在set中已经存在元素位置
iterator insert (const_iterator position, const value_type& val);
iterator insert (const_iterator position, value_type&& val);

// 插入新元素[first,last)
template <class InputIterator>
  void insert (InputIterator first, InputIterator last);

// 将初始化列表l内的元素插入到容器中
void insert (initializer_list<value_type> l);

// 删除位于position的元素，并返回position之后的迭代器
iterator erase (const_iterator position);

// 删除值为val的元素，并返回删除元素的总个数
size_type erase (const value_type& val);

// 删除位置为[first,last)的元素，并返回最后一个移除元素之后的迭代器
iterator  erase (const_iterator first, const_iterator last);

// 用x的内容交换容器的内容
void swap (set& x);

// 清空容器内所有元素
void clear() ;

/* 以args为参数就地构造新元素，并将其插入到容器中。则其成员pair::first设置为一个迭代器，指向新插入的元素或已存在在set 中的元素。如果插入成功，则pair::second元素为true，若该元素已存在，则为false */
pair<iterator,bool> emplace (Args&&... args);

/* 其作用同emplace，但该函数使用position参数作为提示，指示该元素的可能位置，将极大的加快了插入过程 */
iterator emplace_hint (const_iterator position, Args&&... args);

6、查找相关

// 返回容器中元素的键值为key的元素个数 
size_type count( const Key& key ) const

// 查找容器元素中键值为key的元素，并返回其迭代器位置
iterator find( const Key& key );
const_iterator find( const Key& key ) const;

// 查找容器中符合特定要求的键值，并返回两个迭代器:一个指向不小于key的第一个元素，一个指向大于key的第一个元素
std:: pair < iterator,iterator > equal_range ( const Key & key ) ;
std:: pair < const_iterator,const_iterator > equal_range ( const Key & key ) const ;

7、桶操作

// 返回容器中的桶数。
size_type bucket_count() const noexcept;

// 返回容器可以拥有的最大桶数
size_type max_bucket_count() const noexcept;

// 返回容器中桶n的元素数。
size_type bucket_size ( size_type n ) const;

// 返回容器中值为k的元素所在的桶号
size_type bucket ( const key_type& k ) const;

8、哈希策略

// 返回容器的当前负载因子,负载因子是容器中元素个数与桶数的比值：load_factor = size / bucket_count
float load_factor() const noexcept;

// 返回容器的当前最大负载因子
float max_load_factor() const noexcept;

// 将z设置为容器的新最大负载因子,默认为1.0
void max_load_factor ( float z );

// 将容器中的最小桶数设置为n
// 若n大于容器中的当前桶数，则强制进行重新哈希，新的桶数可以等于或大于n。
// 若n小于容器中的当前桶数，则该函数可能对桶数没有影响，并且可能不会强制重新散列。
void rehash ( size_type n );

// 将容器中的桶数设置为最适合包含至少n个元素的桶数
void reserve ( size_type n );

9、容器属性获取

// 返回该容器正在使用的哈希函数对象(一个一元函数，它接受一个key_type类型的对象作为参数，并基于它返回一个size_t类型的唯一值)
hasher hash_function() const;

// 返回容器正在使用的比较函数(一个谓词，它将两个元素 的值作为参数并返回一个布尔值，指示它们是否被认为是等价的)
key_equal key_eq() const;

// 返回用于构造容器的分配器对象。
allocator_type get_allocator() const noexcept;