concurrent_unordered_map-klass

Klassen concurrent_unordered_map är en samtidighetssäker container som styr en sekvens med varierande längd av element av typen std::pair<const K, _Element_type>. Sekvensen representeras på ett sätt som möjliggör samtidighetssäker tillägg, elementåtkomst, iteratoråtkomst och iterator-bläddringar. Här innebär samtidighetssäkert att pekare eller iteratorer alltid är giltiga. Det är inte en garanti för elementinitiering eller en viss bläddreringsordning.

Syntax

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

Parametrar

K
Nyckeltypen.

_Element_type
Den mappade typen.

_Hasher
Objekttypen hash-funktion. Det här argumentet är valfritt och standardvärdet är std::hash<K>.

key_equality
Objekttypen för likhetsjämförelsefunktionen. Det här argumentet är valfritt och standardvärdet är std::equal_to<K>.

_Allocator_type
Den typ som representerar det lagrade allokeringsobjektet som kapslar in information om allokering och frigöring av minne för den samtidiga osorterade kartan. Det här argumentet är valfritt och standardvärdet är std::allocator<std::pair<K, _Element_type>>.

Medlemmar

Offentliga typedefs

Offentliga konstruktorer

Offentliga metoder

Offentliga operatörer

Anmärkningar

Detaljerad information om klassen concurrent_unordered_map finns i Parallella containrar och objekt.

Arvshierarki

_Traits

_Concurrent_hash

concurrent_unordered_map

Krav

rubrik: concurrent_unordered_map.h

namnområde: samtidighet

vid

Hittar ett element i en concurrent_unordered_map med ett angivet nyckelvärde. Den här metoden är samtidighetssäker.

mapped_type& at(const key_type& KVal);

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

Parametrar

KVal
Nyckelvärdet som ska hittas.

Returvärde

En referens till datavärdet för elementet som hittades.

Anmärkningar

Om argumentnyckelvärdet inte hittas genererar funktionen ett objekt av klass out_of_range.

börja

Returnerar en iterator som pekar på det första elementet i den samtidiga containern. Den här metoden är samtidighetssäker.

iterator begin();

const_iterator begin() const;

Returvärde

En iterator till det första elementet i den samtidiga containern.

cbegin

Returnerar en const iterator som pekar på det första elementet i den samtidiga containern. Den här metoden är samtidighetssäker.

const_iterator cbegin() const;

Returvärde

En const iterator till det första elementet i den samtidiga containern.

cend

Returnerar en const-iterator som pekar på platsen som lyckades med det sista elementet i den samtidiga containern. Den här metoden är samtidighetssäker.

const_iterator cend() const;

Returvärde

En const iterator till platsen som lyckades det sista elementet i den samtidiga containern.

klar

Raderar alla element i den samtidiga containern. Den här funktionen är inte samtidighetssäker.

void clear();

concurrent_unordered_map

Konstruerar en samtidig osorterad karta.

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

Parametrar

_Iterator
Typ av iterator för indata.

_Number_of_buckets
Det första antalet bucketar för den här osorterade kartan.

_Hasher
Hash-funktionen för den här osorterade kartan.

key_equality
Likhetsjämförelsefunktionen för den här osorterade kartan.

_Allokeraren
Allokeraren för den här osorterade kartan.

_Börja
Positionen för det första elementet i området med element som ska kopieras.

_Ände
Positionen för det första elementet utöver det område av element som ska kopieras.

_Umap
Källan concurrent_unordered_map objekt att kopiera eller flytta element från.

Anmärkningar

Alla konstruktorer lagrar ett allokeringsobjekt _Allocator och initierar den osorterade kartan.

Den första konstruktorn anger en tom inledande karta och anger uttryckligen antalet bucketar, hash-funktion, likhetsfunktion och allokeringstyp som ska användas.

Den andra konstruktorn anger en allokerare för den osorterade kartan.

Den tredje konstruktorn anger värden som tillhandahålls av iteratorintervallet [ _Begin, _End).

Den fjärde och femte konstruktorn anger en kopia av den samtidiga osorterade kartan _Umap.

Den sista konstruktorn anger en flytt av den samtidiga osorterade kartan _Umap.

räkna

Räknar antalet element som matchar en angiven nyckel. Den här funktionen är samtidighetssäker.

size_type count(const key_type& KVal) const;

Parametrar

KVal
Nyckeln att söka efter.

Returvärde

Antalet gånger som nyckeln visas i containern.

tom

Testar om det inte finns några element. Den här metoden är samtidighetssäker.

bool empty() const;

Returvärde

true om den samtidiga containern är tom false annars.

Anmärkningar

I närvaro av samtidiga infogningar kan om den samtidiga containern är tom ändras omedelbart efter att den här funktionen anropats, innan returvärdet ens läse.

ände

Returnerar en iterator som pekar på platsen som lyckas med det sista elementet i den samtidiga containern. Den här metoden är samtidighetssäker.

iterator end();

const_iterator end() const;

Returvärde

En iterator till platsen som lyckades det sista elementet i den samtidiga containern.

equal_range

Hittar ett intervall som matchar en angiven nyckel. Den här funktionen är samtidighetssäker.

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

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

Parametrar

KVal
Nyckelvärdet att söka efter.

Returvärde

Ett par där det första elementet är en iterator till början och det andra elementet är en iterator i slutet av intervallet.

Anmärkningar

Det är möjligt att samtidiga infogningar gör att ytterligare nycklar infogas efter iteratorn och före slutt iteratorn.

hitta

Hittar ett element som matchar en angiven nyckel. Den här funktionen är samtidighetssäker.

iterator find(const key_type& KVal);

const_iterator find(const key_type& KVal) const;

Parametrar

KVal
Nyckelvärdet att söka efter.

Returvärde

En iterator som pekar på platsen för det första elementet som matchade den angivna nyckeln, eller iteratorn end() om det inte finns något sådant element.

get_allocator

Returnerar det lagrade allokeringsobjektet för den här samtidiga containern. Den här metoden är samtidighetssäker.

allocator_type get_allocator() const;

Returvärde

Det lagrade allokeringsobjektet för den här samtidiga containern.

hash_function

Hämtar det lagrade hash-funktionsobjektet.

hasher hash_function() const;

Returvärde

Det lagrade hash-funktionsobjektet.

infoga

Lägger till element i concurrent_unordered_map-objektet.

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

Parametrar

_Iterator
Den iteratortyp som används för infogning.

V
Typ av värde som infogats i kartan.

värde
Värdet som ska infogas.

_Var
Startplatsen för att söka efter en insättningspunkt.

första
Början av intervallet som ska infogas.

senaste
Slutet av intervallet som ska infogas.

Returvärde

Ett par som innehåller en iterator och ett booleskt värde. Mer information finns i avsnittet Kommentarer.

Anmärkningar

Den första medlemsfunktionen avgör om ett element X finns i sekvensen vars nyckel har motsvarande ordning som value. Annars skapar det ett sådant element X och initierar det med value. Funktionen avgör sedan iteratorn where som anger X. Om en infogning inträffar returnerar funktionen std::pair(where, true). Annars returneras std::pair(where, false).

Den andra medlemsfunktionen returnerar insert(value), med en _Where startplats i den kontrollerade sekvensen för att söka efter insättningspunkten.

Den tredje medlemsfunktionen infogar sekvensen med elementvärden från intervallet [ first, last).

De två sista medlemsfunktionerna fungerar på samma sätt som de två första, förutom att value används för att konstruera det infogade värdet.

key_eq

Hämtar funktionsobjektet för lagrad likhetsjämförelse.

key_equal key_eq() const;

Returvärde

Det lagrade likhetsjämförelsefunktionsobjektet.

load_factor

Beräknar och returnerar containerns aktuella inläsningsfaktor. Belastningsfaktorn är antalet element i containern dividerat med antalet bucketar.

float load_factor() const;

Returvärde

Inläsningsfaktorn för containern.

max_load_factor

Hämtar eller anger containerns maximala belastningsfaktor. Den maximala belastningsfaktorn är det största antalet element än vad som kan finnas i någon bucket innan containern växer sin interna tabell.

float max_load_factor() const;

void max_load_factor(float _Newmax);

Parametrar

_Newmax

Returvärde

Den första medlemsfunktionen returnerar den lagrade maxbelastningsfaktorn. Den andra medlemsfunktionen returnerar inte ett värde men genererar ett out_of_range undantag om den angivna inläsningsfaktorn är ogiltig.

maxstorlek

Returnerar den maximala storleken på den samtidiga containern, som bestäms av allokeraren. Den här metoden är samtidighetssäker.

size_type max_size() const;

Returvärde

Det maximala antalet element som kan infogas i den här samtidiga containern.

Anmärkningar

Det här övre gränsvärdet kan faktiskt vara högre än vad containern faktiskt kan innehålla.

operator[]

Söker efter eller infogar ett element med den angivna nyckeln. Den här metoden är samtidighetssäker.

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

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

Parametrar

KVal
Nyckelvärdet till

hitta eller infoga.

Returvärde

En referens till datavärdet för det hittade eller infogade elementet.

Anmärkningar

Om argumentnyckelvärdet inte hittas infogas det tillsammans med standardvärdet för datatypen.

operator[] kan användas för att infoga element i en mappning m med hjälp av m[key] = DataValue;, där DataValue är värdet för elementets mapped_type med nyckelvärdet key.

När du använder operator[] för att infoga element anger den returnerade referensen inte om en infogning ändrar ett befintligt element eller skapar ett nytt. Medlemsfunktionerna find och infoga kan användas för att avgöra om ett element med en angiven nyckel redan finns före infogningen.

operator=

Tilldelar innehållet i ett annat concurrent_unordered_map objekt till det här objektet. Den här metoden är inte samtidighetssäker.

concurrent_unordered_map& operator= (const concurrent_unordered_map& _Umap);

concurrent_unordered_map& operator= (concurrent_unordered_map&& _Umap);

Parametrar

_Umap
Källobjektet concurrent_unordered_map.

Returvärde

En referens till det här concurrent_unordered_map objektet.

Anmärkningar

När du har raderat befintliga element som en samtidig vektor kopierar eller flyttar operator= innehållet i _Umap till den samtidiga vektorn.

Uppkok

Återskapar hash-tabellen.

void rehash(size_type _Buckets);

Parametrar

_Hinkar
Önskat antal bucketar.

Anmärkningar

Medlemsfunktionen ändrar antalet bucketar som ska vara minst _Buckets och återskapar hash-tabellen efter behov. Antalet bucketar måste vara en effekt på 2. Om inte en kraft på 2 avrundas den upp till nästa största kraft på 2.

Det genererar ett out_of_range undantag om antalet bucketar är ogiltigt (antingen 0 eller större än det maximala antalet bucketar).

storlek

Returnerar antalet element i den här samtidiga containern. Den här metoden är samtidighetssäker.

size_type size() const;

Returvärde

Antalet objekt i containern.

Anmärkningar

I närvaro av samtidiga infogningar kan antalet element i den samtidiga containern ändras omedelbart efter att den här funktionen anropats, innan returvärdet ens läse.

byta

Växlar innehållet i två concurrent_unordered_map objekt. Den här metoden är inte samtidighetssäker.

void swap(concurrent_unordered_map& _Umap);

Parametrar

_Umap
Det concurrent_unordered_map objekt som ska växlas med.

unsafe_begin

Returnerar en iterator till det första elementet i den här containern för en specifik bucket.

local_iterator unsafe_begin(size_type _Bucket);

const_local_iterator unsafe_begin(size_type _Bucket) const;

Parametrar

_Hink
Bucketindexet.

Returvärde

En iterator som pekar på bucketens början.

unsafe_bucket

Returnerar bucketindexet som en specifik nyckel mappar till i den här containern.

size_type unsafe_bucket(const key_type& KVal) const;

Parametrar

KVal
Den elementnyckel som söks efter.

Returvärde

Bucketindexet för nyckeln i den här containern.

unsafe_bucket_count

Returnerar det aktuella antalet bucketar i den här containern.

size_type unsafe_bucket_count() const;

Returvärde

Det aktuella antalet bucketar i den här containern.

unsafe_bucket_size

Returnerar antalet objekt i en specifik bucket i den här containern.

size_type unsafe_bucket_size(size_type _Bucket);

Parametrar

_Hink
Bucketen att söka efter.

Returvärde

Det aktuella antalet bucketar i den här containern.

unsafe_cbegin

Returnerar en iterator till det första elementet i den här containern för en specifik bucket.

const_local_iterator unsafe_cbegin(size_type _Bucket) const;

Parametrar

_Hink
Bucketindexet.

Returvärde

En iterator som pekar på bucketens början.

unsafe_cend

Returnerar en iterator till platsen som lyckades det sista elementet i en specifik bucket.

const_local_iterator unsafe_cend(size_type _Bucket) const;

Parametrar

_Hink
Bucketindexet.

Returvärde

En iterator som pekar på bucketens början.

unsafe_end

Returnerar en iterator till det sista elementet i den här containern för en specifik bucket.

local_iterator unsafe_end(size_type _Bucket);

const_local_iterator unsafe_end(size_type _Bucket) const;

Parametrar

_Hink
Bucketindexet.

Returvärde

En iterator som pekar mot slutet av bucketen.

unsafe_erase

Tar bort element från concurrent_unordered_map på angivna positioner. Den här metoden är inte samtidighetssäker.

iterator unsafe_erase(
    const_iterator _Where);

iterator unsafe_erase(
    const_iterator _Begin,
    const_iterator _End);

size_type unsafe_erase(
    const key_type& KVal);

Parametrar

_Var
Iteratorpositionen att radera från.

_Börja
Positionen för det första elementet i området med element som ska raderas.

_Ände
Positionen för det första elementet utöver det intervall av element som ska raderas.

KVal
Nyckelvärdet som ska raderas.

Returvärde

De två första medlemsfunktionerna returnerar en iterator som anger det första elementet som återstår utöver alla element som tas bort, eller concurrent_unordered_map::end() om det inte finns något sådant element. Den tredje medlemsfunktionen returnerar antalet element som den tar bort.

Anmärkningar

Den första medlemsfunktionen tar bort elementet i den kontrollerade sekvensen som pekas på av _Where. Den andra medlemsfunktionen tar bort elementen i intervallet [ _Begin, _End).

Den tredje medlemsfunktionen tar bort elementen i det intervall som avgränsas av concurrent_unordered_map::equal_range(KVal).

unsafe_max_bucket_count

Returnerar det maximala antalet bucketar i den här containern.

size_type unsafe_max_bucket_count() const;

Returvärde

Det maximala antalet bucketar i den här containern.

Se även

samtidighetsnamnområde
parallella containrar och objekt