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>>。

成員

公用 Typedefs

名稱 描述
allocator_type 管理儲存體的配置器類型。
const_iterator 用於受控制序列的常數迭代器類型。
const_local_iterator 用於受控制序列的常數 Bucket 迭代器類型。
const_pointer 項目的常數指標類型。
const_reference 項目的常數參考類型。
difference_type 兩個項目之間帶正負號距離的類型。
hasher 雜湊函式的類型。
iterator 受控制序列之迭代器的類型。
key_equal 比較函式的類型。
key_type 排序索引鍵的類型。
local_iterator 用於受控制序列的 Bucket 迭代器類型。
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

命名空間： concurrency

時間

在 中 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);

參數

_迭 代
輸入迭代器的類型。

_Number_of_buckets
這個未排序對應的 Bucket 初始數量。

_Hasher
這個未排序對應的雜湊函式。

key_equality
這個未排序對應的相等比較函式。

_分配器
這個未排序對應的配置器。

_開始
要複製的元素範圍中第一個元素的位置。

_結束
超出要複製之元素範圍的第一個元素的位置。

_Umap
要從中複製或移動項目的來源 concurrent_unordered_map 物件。

備註

所有的建構函式都會儲存配置器物件 _Allocator 並初始化未排序的對應。

第一個建構函式會指定空的初始對應，並明確指定要使用的 Bucket、雜湊函式、相等函式和配置器類型的數目。

第二個建構函式會指定未排序對應的配置器。

第三個建構函式會指定反覆運算器範圍 [ 、 _Begin_End 所提供的值。

第四個和第五個建構函式會指定並行未排序之對應 _Umap 的複製作業。

最後一個建構函式會指定並行未排序之對應 _Umap 的移動作業。

計數

計算符合指定索引鍵的專案數目。 此函式是並行安全。

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
要搜尋的索引鍵值。

傳回值

一 對 ，其中第一個專案是開頭的反覆運算器，而第二個元素則是範圍結尾的反覆運算器。

備註

並行插入可能會導致在開始反覆運算器之後和結束反覆運算器之前插入其他索引鍵。

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

參數

_迭 代
用來插入的迭代器類型。

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 中，其中 DataValue 是 mapped_type 具有 索引鍵值的 元素值 key 。 m[key] = DataValue;

當使用 operator[] 插入項目時，傳回的參考不會指出插入是變更預先存在的項目，還是建立新的項目。 成員函式 find 和 插入 可用來判斷具有指定索引鍵的專案是否已經在插入之前。

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 內容複製或移動至並行向量。

重複

重建雜湊資料表。

void rehash(size_type _Buckets);

參數

_桶
所需的貯體數目。

備註

此成員函式會將值區數目改變為至少 _Buckets ，並視需要重建雜湊資料表。 貯體數目必須是 2 的電源。 如果不是 2 的功率，它會四捨五入到下一個最大功率 2。

如果貯體數目無效（0 或大於貯體數目上限），則會擲回 out_of_range 例外狀況。

size

傳回這個並行容器中的項目數目。 這個方法是並行安全。

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;

參數

_桶
貯體索引。

傳回值

指向貯體開頭的反覆運算器。

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

參數

_桶
要搜尋的貯體。

傳回值

此容器中目前的貯體數目。

unsafe_cbegin

將反覆運算器傳回至此容器中特定貯體的第一個專案。

const_local_iterator unsafe_cbegin(size_type _Bucket) const;

參數

_桶
貯體索引。

傳回值

指向貯體開頭的反覆運算器。

unsafe_cend

將反覆運算器傳回至特定貯體中最後一個專案之後的位置。

const_local_iterator unsafe_cend(size_type _Bucket) const;

參數

_桶
貯體索引。

傳回值

指向貯體開頭的反覆運算器。

unsafe_end

將反覆運算器傳回至此容器中特定貯體的最後一個專案。

local_iterator unsafe_end(size_type _Bucket);

const_local_iterator unsafe_end(size_type _Bucket) const;

參數

_桶
貯體索引。

傳回值

指向貯體結尾的反覆運算器。

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
要清除的反覆運算器位置。

_開始
項目範圍中要清除的第一個項目的位置。

_結束
超出要清除之項目範圍的第一個項目的位置。

KVal
要清除的索引鍵值。

傳回值

前兩個成員函式會傳回反覆運算器，指定移除任何元素以外的第一個元素，如果不存在這類專案，則 concurrent_unordered_map::end 為 （）。 第三個成員函式會傳回它移除的專案數目。

備註

第一個成員函式會移除 _Where 所指向之受控制序列中的項目。 第二個成員函式會移除範圍 [ _Begin 、 _End 中的專案。

第三個成員函式會移除以 （KVal） 分隔 concurrent_unordered_map::equal_range 之範圍中的元素。

unsafe_max_bucket_count

傳回此容器中的貯體數目上限。

size_type unsafe_max_bucket_count() const;

傳回值

此容器中的貯體數目上限。

另請參閱

concurrency 命名空間
平行容器和物件