concurrent_unordered_map-klasse

De concurrent_unordered_map-klasse is een gelijktijdigheidsveilige container die een wisselende reeks elementen van het type std::pair<const K, _Element_type>beheert. De reeks wordt weergegeven op een manier waarmee gelijktijdigheidsveilige toevoeg-, elementtoegang, iterator-toegang en iterator-traversal-bewerkingen mogelijk zijn. Hier zijn gelijktijdigheidsveilige aanwijzers of iterators altijd geldig. Het biedt geen garantie voor het initialiseren van elementen of voor een specifieke traverseringsvolgorde.

Syntaxis

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

Parameterwaarden

K
Het sleuteltype.

_Element_type
Het gemapte type.

_Hasher
Het type hashfunctie-object. Dit argument is optioneel en de standaardwaarde is std::hash<K>.

sleutel_gelijkheid
Het type object voor gelijkheidsvergelijkingsfuncties. Dit argument is optioneel en de standaardwaarde is std::equal_to<K>.

_Allocator_type
Het type dat het opgeslagen allocatorobject vertegenwoordigt en details bevat over de toewijzing en vrijgave van geheugen voor de gelijktijdige niet-geordende map. Dit argument is optioneel en de standaardwaarde is std::allocator<std::pair<K, _Element_type>>.

Leden

Openbare typedefs

Naam	Beschrijving
allocator_type	Het type allocator voor het beheren van opslag.
const_iterator	Het type van een constante iterator voor de gecontroleerde reeks.
const_local_iterator	Het type van een constante bucket-iterator voor de gecontroleerde reeks.
const_pointer	Het type van een constante pointer naar een element.
const_reference	Het type van een constante verwijzing naar een element.
difference_type	Het type ondertekende afstand tussen twee elementen.
hasher	Het type hash-functie.
iterator	Het type iterator voor de gecontroleerde reeks.
key_equal	Het type vergelijkingsfunctie.
key_type	Het type van een orderingssleutel.
local_iterator	Het type bucket-iterator voor de bestuurde reeks.
mapped_type	Het type van een toegewezen waarde dat is geassocieerd met elke sleutel.
pointer	Het type pointer naar een element.
reference	Het type verwijzing naar een element.
size_type	Het type niet-ondertekende afstand tussen twee elementen.
value_type	Het type van een element.

Openbare constructors

Naam	Beschrijving
concurrent_unordered_map	Overbelast. Maakt een gelijktijdige niet-geordende kaart.

Openbare methoden

Naam	Beschrijving
bij	Overbelast. Hiermee zoekt u een element in een concurrent_unordered_map met een opgegeven sleutelwaarde. Deze methode is gelijktijdigheidsveilig.
hash_function	Hiermee haalt u het opgeslagen hash-functieobject op.
invoegen	Overbelast. Voegt elementen toe aan het concurrent_unordered_map-object.
key_eq	Hiermee haalt u het opgeslagen functieobject voor gelijkheidsvergelijking op.
wisselen	Wisselt de inhoud van twee concurrent_unordered_map objecten. Deze methode is niet gelijktijdigheidsveilig.
unsafe_erase	Overbelast. Hiermee verwijdert u elementen uit de concurrent_unordered_map op opgegeven posities. Deze methode is niet gelijktijdigheidsveilig.

Openbare operators

Naam	Beschrijving
operator []	Overbelast. Hiermee wordt een element met de opgegeven sleutel gevonden of ingevoegd. Deze methode is gelijktijdigheidsveilig.
operator =	Overbelast. Hiermee wordt de inhoud van een ander concurrent_unordered_map object aan dit object toegewezen. Deze methode is niet gelijktijdigheidsveilig.

Opmerkingen

Zie concurrent_unordered_map voor gedetailleerde informatie over de klasse Parallelle Containers en Objecten.

Overnamehiërarchie

_Traits

_Concurrent_hash

concurrent_unordered_map

Eisen

koptekst: concurrent_unordered_map.h

Namespace: gelijktijdigheid

op

Hiermee zoekt u een element in een concurrent_unordered_map met een opgegeven sleutelwaarde. Deze methode is gelijktijdigheidsveilig.

mapped_type& at(const key_type& KVal);

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

Parameterwaarden

KVal
De sleutelwaarde die moet worden gevonden.

Retourwaarde

Een verwijzing naar de gegevenswaarde van het gevonden element.

Opmerkingen

Als de waarde van de argumentsleutel niet wordt gevonden, genereert de functie een object van klasse out_of_range.

beginnen

Hiermee wordt een iterator geretourneerd die verwijst naar het eerste element in de gelijktijdige container. Deze methode is veilig voor gelijktijdigheid.

iterator begin();

const_iterator begin() const;

Retourwaarde

Een iterator naar het eerste element in de concurrerende container.

cbegin

Retourneert een const iterator die verwijst naar het eerste element in de gelijktijdige container. Deze methode is veilig voor gelijktijdigheid.

const_iterator cbegin() const;

Retourwaarde

Een const-iterator naar het eerste element in de gelijktijdige container.

cend

Retourneert een const iterator die verwijst naar de locatie die volgt op het laatste element in de concurrente container. Deze methode is veilig voor gelijktijdigheid.

const_iterator cend() const;

Retourwaarde

Een const iterator voor de positie na het laatste element in de gelijktijdige container.

duidelijk

Hiermee worden alle elementen in de concurrerende container gewist. Deze functie is niet veilig voor gelijktijdigheid.

void clear();

concurrent_unordered_map

Maakt een gelijktijdige niet-geordende kaart.

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

Parameterwaarden

_Iterator
Het type invoer-iterator.

_Aantal_emmers
Het eerste aantal buckets voor deze niet-geordende kaart.

_Hasher
De hash-functie voor deze niet-geordende kaart.

sleutel_gelijkheid
De gelijkheidsvergelijkingsfunctie voor deze niet-geordende kaart.

_Allocator
De allocator voor deze niet-geordende kaart.

_Beginnen
De positie van het eerste element in het bereik van elementen dat moet worden gekopieerd.

_Einde
De positie van het eerste element buiten het bereik van elementen dat moet worden gekopieerd.

_Umap
Het bronobject concurrent_unordered_map waarvan elementen worden gekopieerd of verplaatst.

Opmerkingen

Alle constructors slaan een allocatorobject op _Allocator en initialiseren de ongeordeerde kaart.

De eerste constructor specificeert een lege eerste kaart en geeft expliciet het aantal buckets, hash-functie, gelijkheidsfunctie en allocatortype op dat moet worden gebruikt.

De tweede constructor geeft een allocator op voor de niet-geordende kaart.

De derde constructor geeft waarden op die worden opgegeven door het iteratorbereik [ _Begin, _End).

De vierde en vijfde constructors geven een kopie op van de gelijktijdige niet-geordende kaart _Umap.

De laatste constructor specificeert een verplaatsingsoperatie van de niet-geordende gelijktijdige map _Umap.

aantal

Telt het aantal elementen dat overeenkomt met een opgegeven sleutel. Deze functie is veilig voor gelijktijdigheid.

size_type count(const key_type& KVal) const;

Parameterwaarden

KVal
De sleutel waarnaar moet worden gezocht.

Retourwaarde

Het aantal keren dat de sleutel in de container wordt weergegeven.

leeg

Test of er geen elementen aanwezig zijn. Deze methode is veilig voor gelijktijdigheid.

bool empty() const;

Retourwaarde

true als de concurrerende container leeg is, false anders.

Opmerkingen

Wanneer er gelijktijdige invoegingen plaatsvinden, kan het voorkomen dat de status van de gelijktijdige container (leeg of niet) verandert direct na het aanroepen van deze functie, zelfs voordat de retourwaarde is gelezen.

einde

Retourneert een iterator die verwijst naar de locatie die volgt op het laatste element in de concurrente container. Deze methode is veilig voor gelijktijdigheid.

iterator end();

const_iterator end() const;

Retourwaarde

Een iterator naar de locatie die volgt op het laatste element in de gelijktijdige container.

equal_range

Hiermee zoekt u een bereik dat overeenkomt met een opgegeven sleutel. Deze functie is veilig voor gelijktijdigheid.

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

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

Parameterwaarden

KVal
De sleutelwaarde om naar te zoeken.

Retourwaarde

Een paar waarbij het eerste element een iterator aan het begin is en het tweede element een iterator aan het einde van het bereik is.

Opmerkingen

Het is mogelijk dat gelijktijdige invoegingen ervoor zorgen dat er extra sleutels worden ingevoegd na de begin-iterator en vóór de eind-iterator.

vinden

Hiermee zoekt u een element dat overeenkomt met een opgegeven sleutel. Deze functie is veilig voor gelijktijdigheid.

iterator find(const key_type& KVal);

const_iterator find(const key_type& KVal) const;

Parameterwaarden

KVal
De sleutelwaarde om naar te zoeken.

Retourwaarde

Een iterator die verwijst naar de locatie van het eerste element dat overeenkomt met de opgegeven sleutel of de iterator end() als er geen dergelijk element bestaat.

get_allocator

Retourneert het opgeslagen allocatorobject voor deze gelijktijdige container. Deze methode is veilig voor gelijktijdigheid.

allocator_type get_allocator() const;

Retourwaarde

Het opgeslagen allocatorobject voor deze gelijktijdige container.

hash_function

Hiermee haalt u het opgeslagen hash-functieobject op.

hasher hash_function() const;

Retourwaarde

Het opgeslagen hash-functieobject.

invoegen

Voegt elementen toe aan het concurrent_unordered_map-object.

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

Parameterwaarden

_Iterator
Het iteratortype dat wordt gebruikt voor invoeging.

V
Het type van de waarde die in de kaart is ingevoegd.

waarde
De waarde die moet worden ingevoegd.

_Waar
De beginlocatie om naar een invoegpositie te zoeken.

eerste
Het begin van het bereik dat moet worden ingevoegd.

laatste
Het eindpunt van het bereik dat moet worden ingevoegd.

Retourwaarde

Een paar dat een iterator en een Booleaanse waarde bevat. Zie de sectie Opmerkingen voor meer informatie.

Opmerkingen

De eerste lidfunctie bepaalt of een element X bestaat in de reeks waarvan de sleutel equivalent is aan die van value. Zo niet, dan wordt een dergelijk element X gemaakt en geïnitialiseerd met value. De functie bepaalt vervolgens de iterator where die X aanwijst. Als er een invoeging is opgetreden, retourneert de functie std::pair(where, true). Anders wordt std::pair(where, false) geretourneerd.

De tweede lidfunctie retourneert insert(value), waarbij wordt gebruikt _Where als uitgangspunt binnen de gecontroleerde volgorde om naar de invoegpositie te zoeken.

De derde lidfunctie voegt de reeks elementwaarden uit het bereik [ first, last) in.

De laatste twee lidfuncties gedragen zich hetzelfde als de eerste twee, behalve dat value wordt gebruikt om de ingevoegde waarde samen te stellen.

key_eq

Hiermee haalt u het opgeslagen functieobject voor gelijkheidsvergelijking op.

key_equal key_eq() const;

Retourwaarde

Het opgeslagen object voor de gelijkheidsvergelijkingsfunctie.

load_factor

Berekent en retourneert de huidige belastingfactor van de container. De belastingfactor is het aantal elementen in de container gedeeld door het aantal buckets.

float load_factor() const;

Retourwaarde

De laadfactor voor de container.

max_load_factor

Hiermee haalt u de maximale laadfactor van de container op of stelt u deze in. De maximale belastingfactor is het grootste aantal elementen dat in een bucket kan staan voordat de container zijn interne tabel vergroot.

float max_load_factor() const;

void max_load_factor(float _Newmax);

Parameterwaarden

_Newmax

Retourwaarde

De eerste lidfunctie retourneert de opgeslagen maximale belastingsfactor. De functie tweede lid retourneert geen waarde, maar genereert een out_of_range uitzondering als de opgegeven belastingfactor ongeldig is.

maximale_grootte

Retourneert de maximale grootte van de gelijktijdige container, bepaald door de allocator. Deze methode is veilig voor gelijktijdigheid.

size_type max_size() const;

Retourwaarde

Het maximum aantal elementen dat in deze gelijktijdige container kan worden ingevoegd.

Opmerkingen

Deze bovengrenswaarde kan in feite hoger zijn dan wat de container daadwerkelijk kan bevatten.

operator[]

Hiermee wordt een element met de opgegeven sleutel gevonden of ingevoegd. Deze methode is gelijktijdigheidsveilig.

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

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

Parameterwaarden

KVal
De sleutelwaarde voor

zoeken of invoegen.

Retourwaarde

Een verwijzing naar de gegevenswaarde van het gevonden of ingevoegde element.

Opmerkingen

Als de argumentsleutelwaarde niet wordt gevonden, wordt deze samen met de standaardwaarde van het gegevenstype ingevoegd.

operator[] kan worden gebruikt om elementen in te voegen in een kaart m met behulp van m[key] = DataValue;, waarbij DataValue de waarde is van de mapped_type van het element met een sleutelwaarde van key.

Wanneer u operator[] gebruikt om elementen in te voegen, geeft de geretourneerde verwijzing niet aan of een invoeging een bestaand element wijzigt of een nieuw element maakt. De lidfuncties find en invoegen kunnen worden gebruikt om te bepalen of een element met een opgegeven sleutel al aanwezig is vóór een invoeging.

operator=

Hiermee wordt de inhoud van een ander concurrent_unordered_map object aan dit object toegewezen. Deze methode is niet gelijktijdigheidsveilig.

concurrent_unordered_map& operator= (const concurrent_unordered_map& _Umap);

concurrent_unordered_map& operator= (concurrent_unordered_map&& _Umap);

Parameterwaarden

_Umap
Het bronobject concurrent_unordered_map.

Retourwaarde

Een verwijzing naar dit concurrent_unordered_map-object.

Opmerkingen

Nadat alle bestaande elementen uit een concurrentievector zijn verwijderd, kopieert of verplaatst operator= de inhoud van _Umap naar de concurrentievector.

herhalen

Hiermee wordt de hash-tabel opnieuw opgebouwd.

void rehash(size_type _Buckets);

Parameterwaarden

_Buckets
Het gewenste aantal buckets.

Opmerkingen

De lidfunctie wijzigt het aantal buckets dat ten minste _Buckets is en herbouwt de hash-tabel indien nodig. Het aantal buckets moet een macht van 2 zijn. Als er geen macht van 2 is, wordt het naar boven afgerond op de eerstvolgende grootste macht van 2.

Er wordt een out_of_range uitzondering gegenereerd als het aantal buckets ongeldig is (0 of groter dan het maximum aantal buckets).

grootte

Retourneert het aantal elementen in deze gelijktijdige container. Deze methode is veilig voor gelijktijdigheid.

size_type size() const;

Retourwaarde

Het aantal items in de container.

Opmerkingen

In aanwezigheid van gelijktijdige invoegingen kan het aantal elementen in de gelijktijdige container onmiddellijk na het aanroepen van deze functie veranderen voordat de retourwaarde zelfs wordt gelezen.

wisselen

Wisselt de inhoud van twee concurrent_unordered_map objecten. Deze methode is niet gelijktijdigheidsveilig.

void swap(concurrent_unordered_map& _Umap);

Parameterwaarden

_Umap
Het concurrent_unordered_map object waarmee gewisseld wordt.

unsafe_begin

Retourneert een iterator naar het eerste element in deze container voor een specifieke bucket.

local_iterator unsafe_begin(size_type _Bucket);

const_local_iterator unsafe_begin(size_type _Bucket) const;

Parameterwaarden

_Bucket
De bucketindex.

Retourwaarde

Een iterator die naar het begin van de bucket wijst.

onveilige_emmer

Retourneert de bucket-index waar een specifieke sleutel naar verwijst in deze container.

size_type unsafe_bucket(const key_type& KVal) const;

Parameterwaarden

KVal
De elementsleutel die wordt gezocht.

Retourwaarde

De bucket-index voor de sleutel in deze container.

onveilige_emmer_telling

Retourneert het huidige aantal buckets in deze container.

size_type unsafe_bucket_count() const;

Retourwaarde

Het huidige aantal buckets in deze container.

onveilig_emmergrootte

Retourneert het aantal items in een specifieke bucket van deze container.

size_type unsafe_bucket_size(size_type _Bucket);

Parameterwaarden

_Bucket
De bucket waarnaar gezocht moet worden.

Retourwaarde

Het huidige aantal buckets in deze container.

unsafe_cbegin

Retourneert een iterator naar het eerste element in deze container voor een specifieke bucket.

const_local_iterator unsafe_cbegin(size_type _Bucket) const;

Parameterwaarden

_Bucket
De bucketindex.

Retourwaarde

Een iterator die naar het begin van de bucket wijst.

unsafe_cend

Retourneert een iterator naar de positie na het laatste element in een specifieke bucket.

const_local_iterator unsafe_cend(size_type _Bucket) const;

Parameterwaarden

_Bucket
De bucketindex.

Retourwaarde

Een iterator die naar het begin van de bucket wijst.

unsafe_end

Hiermee wordt een iterator geretourneerd naar het laatste element in deze container voor een specifieke bucket.

local_iterator unsafe_end(size_type _Bucket);

const_local_iterator unsafe_end(size_type _Bucket) const;

Parameterwaarden

_Bucket
De bucketindex.

Retourwaarde

Een iterator die naar het einde van de bucket wijst.

onveilig_verwijderen

Hiermee verwijdert u elementen uit de concurrent_unordered_map op opgegeven posities. Deze methode is niet gelijktijdigheidsveilig.

iterator unsafe_erase(
    const_iterator _Where);

iterator unsafe_erase(
    const_iterator _Begin,
    const_iterator _End);

size_type unsafe_erase(
    const key_type& KVal);

Parameterwaarden

_Waar
De iteratorpositie waaruit moet worden gewist.

_Beginnen
De positie van het eerste element in het bereik van elementen dat moet worden gewist.

_Einde
De positie van het eerste element buiten het bereik van elementen dat moet worden gewist.

KVal
De sleutelwaarde die moet worden gewist.

Retourwaarde

De eerste twee lidfuncties retourneren een iterator die het eerste element aanwijst dat buiten alle verwijderde elementen blijft, of concurrent_unordered_map::end() als er geen dergelijk element bestaat. De functie derde lid retourneert het aantal elementen dat wordt verwijderd.

Opmerkingen

Met de eerste lidfunctie wordt het element van de gecontroleerde reeks verwijderd dat wordt verwezen door _Where. De tweede lidfunctie verwijdert de elementen in het bereik [ _Begin, _End).

Met de functie derde lid worden de elementen in het bereik verwijderd dat wordt gescheiden door concurrent_unordered_map::equal_range(KVal).

onveilig_max_bucket_aantal

Retourneert het maximum aantal buckets in deze container.

size_type unsafe_max_bucket_count() const;

Retourwaarde

Het maximum aantal buckets in deze container.

Zie ook

concurrency namespace
parallelle containers en objecten