concurrent_unordered_map 类

concurrent_unordered_map 类是控制 std::pair<const K, _Element_type> 类型元素的长短不一序列的并发安全容器。 序列以支持并发安全追加、元素访问、迭代器访问和迭代器遍历操作的方式表示。 在这里，并发安全意味着指针或迭代器始终有效。 它不保证元素初始化或特定的遍历顺序。

语法

template <typename K,
    typename _Element_type,
    typename _Hasher = std::hash<K>,
    typename key_equality = std::equal_to<K>,
    typename _Allocator_type = std::allocator<std::pair<const K,
    _Element_type>>
>,
typename key_equality = std::equal_to<K>,
    typename _Allocator_type = std::allocator<std::pair<const K,
    _Element_type>>> class concurrent_unordered_map : public details::_Concurrent_hash<details::_Concurrent_unordered_map_traits<K,
    _Element_type,
details::_Hash_compare<K,
    _Hasher,
key_equality>,
    _Allocator_type,
false>>;

参数

K
键类型。

_Element_type
映射类型。

_Hasher
哈希函数对象类型。 此参数为可选参数，默认值为 std::hash<K>。

key_equality
相等比较函数对象类型。 此参数为可选参数，默认值为 std::equal_to<K>。

_Allocator_type
一种表示存储的分配器对象的类型，该分配器对象封装有关并发无序映射的内存分配和解除分配的详细信息。 此参数为可选参数，默认值为 std::allocator<std::pair<K 和 _Element_type>>。

成员

公共 Typedef

名称	描述
allocator_type	用于管理存储的分配器的类型。
const_iterator	受控序列的常量迭代器的类型。
const_local_iterator	受控序列的常量存储桶迭代器的类型。
const_pointer	元素的常量指针的类型。
const_reference	元素的常量引用的类型。
difference_type	两个元素间的带符号距离的类型。
hasher	哈希函数的类型。
iterator	受控序列的迭代器的类型。
key_equal	比较函数的类型。
key_type	排序键的类型。
local_iterator	受控序列的存储桶迭代器的类型。
mapped_type	与每个键关联的映射值的类型。
pointer	指向元素的指针的类型。
reference	元素的引用的类型。
size_type	两个元素间的无符号距离的类型。
value_type	元素的类型。

公共构造函数

名称	描述
concurrent_unordered_map	已重载。 构造并发无序映射。

公共方法

名称	描述
at	已重载。 在 concurrent_unordered_map 中查找具有指定关键字值的元素。 此方法是并发安全的。
hash_function	获取存储的哈希函数对象。
insert	已重载。 向 concurrent_unordered_map 对象添加元素。
key_eq	获取存储的相等比较函数对象。
swap	交换两个 concurrent_unordered_map 对象的内容。 此方法不是并发安全方法。
unsafe_erase	已重载。 从 concurrent_unordered_map 中的指定位置移除元素。 此方法不是并发安全方法。

公共运算符

“属性”	描述
operator[]	已重载。 查找或插入具有指定键的元素。 此方法是并发安全的。
operator=	已重载。 将另一 concurrent_unordered_map 对象的内容分配给此对象。 此方法不是并发安全方法。

注解

有关 concurrent_unordered_map 类的详细信息，请参阅并行容器和对象。

继承层次结构

_Traits

_Concurrent_hash

concurrent_unordered_map

要求

标头：concurrent_unordered_map.h

命名空间： 并发

at

在 concurrent_unordered_map 中查找具有指定关键字值的元素。 此方法是并发安全的。

mapped_type& at(const key_type& KVal);

const mapped_type& at(const key_type& KVal) const;

参数

KVal
要查找的键值。

返回值

对找到的元素数据值的引用。

备注

如果未找到自变量键值，函数将引发类 out_of_range 的对象。

begin

返回指向并发容器中第一个元素的迭代器。 此方法是并发安全的。

iterator begin();

const_iterator begin() const;

返回值

并发容器中第一个元素的迭代器。

cbegin

返回指向并发容器中第一个元素的 const 迭代器。 此方法是并发安全的。

const_iterator cbegin() const;

返回值

指向并发容器中第一个元素的 const 迭代器。

cend

返回一个 const 迭代器，指向并发容器中最后一个元素之后的位置。 此方法是并发安全的。

const_iterator cend() const;

返回值

一个 const 迭代器，指向并发容器中最后一个元素之后的位置。

clear

擦除并发容器中的所有元素。 此函数不是并发安全的。

void clear();

concurrent_unordered_map

构造并发无序映射。

explicit concurrent_unordered_map(
    size_type _Number_of_buckets = 8,
    const hasher& _Hasher = hasher(),
    const key_equal& key_equality = key_equal(),
    const allocator_type& _Allocator = allocator_type());

concurrent_unordered_map(
    const allocator_type& _Allocator);

template <typename _Iterator>
concurrent_unordered_map(_Iterator _Begin,
    _Iterator _End,
    size_type _Number_of_buckets = 8,
    const hasher& _Hasher = hasher(),
    const key_equal& key_equality = key_equal(),
    const allocator_type& _Allocator = allocator_type());

concurrent_unordered_map(
    const concurrent_unordered_map& _Umap);

concurrent_unordered_map(
    const concurrent_unordered_map& _Umap,
    const allocator_type& _Allocator);

concurrent_unordered_map(
    concurrent_unordered_map&& _Umap);

参数

_Iterator
输入迭代器的类型。

_Number_of_buckets
此无序映射的初始存储桶数。

_Hasher
此无序映射的哈希函数。

key_equality
此无序映射的相等性比较函数。

_Allocator
此无序映射的分配器。

_Begin
要复制的范围元素中的第一个元素的位置。

_End
要复制的元素范围以外的第一个元素的位置。

_Umap
要从中复制或移动元素的源 concurrent_unordered_map 对象。

备注

所有构造函数都会存储一个分配器对象 _Allocator 并初始化无序映射。

第一个构造函数指定一个空的初始映射，并显式指定要使用的存储桶的数量、哈希函数、相等性比较函数和分配器类型。

第二个构造函数指定无序映射的分配器。

第三个构造函数指定迭代器范围 [_Begin, _End) 提供的值。

第四个和第五个构造函数指定并发无序映射 _Umap 的副本。

最后一个构造函数指定并发无序映射 _Umap的移动。

count

计算与指定键匹配的元素数。 此函数是并发安全的。

size_type count(const key_type& KVal) const;

参数

KVal
要搜索的键。

返回值

键出现在容器中的次数。

empty

测试元素是否存在。 此方法是并发安全的。

bool empty() const;

返回值

如果并发容器为空，则为 true；否则为 false。

备注

在存在并发插入的情况下，并发容器是否为空可能会在调用此函数后立即更改，甚至在读取返回值之前。

end

返回一个迭代器，指向并发容器中最后一个元素之后的位置。 此方法是并发安全的。

iterator end();

const_iterator end() const;

返回值

一个迭代器，指向并发容器中最后一个元素之后的位置。

equal_range

查找与指定键匹配的范围。 此函数是并发安全的。

std::pair<iterator,
    iterator> equal_range(
    const key_type& KVal);

std::pair<const_iterator,
    const_iterator> equal_range(
    const key_type& KVal) const;

参数

KVal
要搜索的键值。

返回值

一个 pair 结构，其中第一个元素是指向开头的迭代器，第二个元素是指向范围末尾的迭代器。

备注

并发插入可能会导致在开始迭代器之后和结束迭代器之前插入额外的键。

find

查找与指定键匹配的元素。 此函数是并发安全的。

iterator find(const key_type& KVal);

const_iterator find(const key_type& KVal) const;

参数

KVal
要搜索的键值。

返回值

一个迭代器，指向与提供的键匹配的第一个元素的位置，如果不存在这样的元素，则为迭代器 end()。

get_allocator

返回此并发容器的存储分配器对象。 此方法是并发安全的。

allocator_type get_allocator() const;

返回值

此并发容器的存储分配器对象。

hash_function

获取存储的哈希函数对象。

hasher hash_function() const;

返回值

存储的哈希函数对象。

insert

向 concurrent_unordered_map 对象添加元素。

std::pair<iterator,
    bool> insert(
    const value_type& value);

iterator insert(
    const_iterator _Where,
    const value_type& value);

template<class _Iterator>
void insert(_Iterator first,
    _Iterator last);

template<class V>
std::pair<iterator,
    bool> insert(
    V&& value);

template<class V>
typename std::enable_if<!std::is_same<const_iterator,
    typename std::remove_reference<V>::type>::value,
    iterator>::type insert(
    const_iterator _Where,
    V&& value);

参数

_Iterator
用于插入的迭代器类型。

V
插入到映射中的值的类型。

value
要插入的值。

_Where
搜索插入点的起始位置。

first
要插入的范围的开始处。

last
要插入的范围的结尾处。

返回值

包含迭代器和布尔值的对。 有关更多详细信息，请参阅“备注”部分。

注解

第一个成员函数确定元素 X 是否存在于其键与 value 的键具有等效顺序的序列中。 如果不是，它会创建此类元素 X 并使用 value 对其进行初始化。 然后该函数确定指定 X 的迭代器 where。如果发生插入，则该函数返回 std::pair(where, true)。 否则，它将返回 std::pair(where, false)。

第二个成员函数返回 insert(value)，使用 _Where 作为受控序列中的起始位置来搜索插入点。

第三个成员函数插入范围 [first, last) 中的元素值序列。

最后两个成员函数与前两个成员函数的行为相同，除了 value 用于构造插入值外。

key_eq

获取存储的相等比较函数对象。

key_equal key_eq() const;

返回值

存储的相等比较函数对象。

load_factor

计算并返回容器的当前负载因子。 负载因子是容器中元素的数量除以桶的数量。

float load_factor() const;

返回值

容器的负载系数。

max_load_factor

获取或设置容器的最大负载因子。 最大负载因子是在容器增长其内部表之前任何存储桶中的最大元素数。

float max_load_factor() const;

void max_load_factor(float _Newmax);

参数

_Newmax

返回值

第一个成员函数将返回存储的最大加载因子。 如果提供的负载因子无效，第二个成员函数不会返回值，但会引发 out_of_range 异常。

max_size

返回由分配器确定的并发容器的最大大小。 此方法是并发安全的。

size_type max_size() const;

返回值

可以插入此并发容器的最大元素数。

备注

这个上限值实际上可能高于容器实际可以容纳的值。

operator[]

查找或插入具有指定键的元素。 此方法是并发安全的。

mapped_type& operator[](const key_type& kval);

mapped_type& operator[](key_type&& kval);

参数

KVal
要

查找或插入的键值。

返回值

对找到或插入的元素数据值的引用。

备注

如果未找到自变量键值，则它将与数据类型的默认值一起插入。

operator[] 可用于将元素插入使用 m（其中 m[key] = DataValue; 是具有键值 DataValue 的元素 mapped_type 的值）的映射 key。

使用 operator[] 插入元素时，返回的引用不指示插入是更改预先存在的元素还是创建一个新元素。 成员函数 find 和 insert 可用于确定具有指定键的元素在插入前是否已存在。

operator=

将另一 concurrent_unordered_map 对象的内容分配给此对象。 此方法不是并发安全方法。

concurrent_unordered_map& operator= (const concurrent_unordered_map& _Umap);

concurrent_unordered_map& operator= (concurrent_unordered_map&& _Umap);

参数

_Umap
源 concurrent_unordered_map 对象。

返回值

对此 concurrent_unordered_map 对象的引用。

备注

在清除并发向量中的所有现有元素后，operator= 会将 _Umap 的内容复制或移动到此并发向量中。

rehash

重新生成哈希表。

void rehash(size_type _Buckets);

参数

_Buckets
所需的桶数。

备注

成员函数将存储桶数更改为至少 _Buckets 并根据需要重新生成哈希表。 桶的数量必须是 2 的幂。 如果不是 2 的幂，将向上取整到 2 的下一个最大幂。

如果存储桶数无效（0 或大于最大存储桶数），则会引发 out_of_range 异常。

大小

返回此并发容器中的元素数量。 此方法是并发安全的。

size_type size() const;

返回值

容器中的项数。

备注

在存在并发插入时，并发容器中的元素数量可能会在调用此函数后立即更改，甚至会在读取返回值之前。

swap

交换两个 concurrent_unordered_map 对象的内容。 此方法不是并发安全方法。

void swap(concurrent_unordered_map& _Umap);

参数

_Umap
要交换的 concurrent_unordered_map 对象。

unsafe_begin

为特定存储桶返回此容器中第一个元素的迭代器。

local_iterator unsafe_begin(size_type _Bucket);

const_local_iterator unsafe_begin(size_type _Bucket) const;

参数

_Bucket
桶索引。

返回值

指向桶开头的迭代器。

unsafe_bucket

返回此容器中特定键映射到的存储桶索引。

size_type unsafe_bucket(const key_type& KVal) const;

参数

KVal
正在搜索的元素键。

返回值

此容器中键的桶索引。

unsafe_bucket_count

返回此容器中的当前桶数。

size_type unsafe_bucket_count() const;

返回值

此容器中的当前存储桶数。

unsafe_bucket_size

返回此容器的特定存储桶中的项数。

size_type unsafe_bucket_size(size_type _Bucket);

参数

_Bucket
要搜索的存储桶。

返回值

此容器中的当前存储桶数。

unsafe_cbegin

为特定存储桶返回此容器中第一个元素的迭代器。

const_local_iterator unsafe_cbegin(size_type _Bucket) const;

参数

_Bucket
桶索引。

返回值

指向桶开头的迭代器。

unsafe_cend

将迭代器返回到特定存储桶中最后一个元素之后的位置。

const_local_iterator unsafe_cend(size_type _Bucket) const;

参数

_Bucket
桶索引。

返回值

指向桶开头的迭代器。

unsafe_end

为特定存储桶返回此容器中最后一个元素的迭代器。

local_iterator unsafe_end(size_type _Bucket);

const_local_iterator unsafe_end(size_type _Bucket) const;

参数

_Bucket
桶索引。

返回值

指向桶末尾的迭代器。

unsafe_erase

从 concurrent_unordered_map 中的指定位置移除元素。 此方法不是并发安全方法。

iterator unsafe_erase(
    const_iterator _Where);

iterator unsafe_erase(
    const_iterator _Begin,
    const_iterator _End);

size_type unsafe_erase(
    const key_type& KVal);

参数

_Where
要擦除的迭代器位置。

_Begin
要消除的元素范围中第一个元素的位置。

_End
要消除的元素范围之外的第一个元素的位置。

KVal
要擦除的键值。

返回值

前两个成员函数返回一个迭代器，该迭代器指定除任何已删除元素之外剩余的第一个元素，如果不存在这样的元素，则返回 concurrent_unordered_map::end()。 第三个成员函数返回它删除的元素数。

注解

第一个成员函数将移除 _Where 所指向的受控序列的元素。 第二个成员函数删除范围 [_Begin, _End) 中的元素。

第三个成员函数删除由 concurrent_unordered_map::equal_range (KVal) 分隔的范围内的元素。

unsafe_max_bucket_count

返回此容器中的最大桶数。

size_type unsafe_max_bucket_count() const;

返回值

此容器中的最大桶数。

另请参阅

并发命名空间
并行容器和对象