Classe concurrent_unordered_map

La classe concurrent_unordered_map è un contenitore indipendente dalla concorrenza che controlla una sequenza di lunghezza variabile di elementi di tipo std::pair<const K, _Element_type>. La sequenza viene rappresentata in un modo che abilita le operazioni di accodamento, accesso elementi, accesso iteratori e attraversamento iteratori in modo indipendente dalla concorrenza. In questo caso, i puntatori o gli iteratori sicuri per la concorrenza sono sempre validi. Non è una garanzia di inizializzazione degli elementi o di un ordine attraversamento specifico.

Sintassi

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

Parametri

K
Tipo di chiave.

_Element_type
Tipo mappato.

_Hasher
Tipo di oggetto della funzione hash. Questo argomento è facoltativo e il valore predefinito è std::hash<K>.

key_equality
Tipo di oggetto della funzione di confronto di uguaglianza. Questo argomento è facoltativo e il valore predefinito è std::equal_to<K>.

_Allocator_type
Tipo che rappresenta l'oggetto allocatore archiviato che incapsula i dettagli sull'allocazione e la deallocazione della memoria per la mappa simultanea non ordinata. Questo argomento è facoltativo e il valore predefinito è std::allocator<std::pair<K,_Element_type>>.

Membri

Typedef pubblici

Nome	Descrizione
allocator_type	Tipo di un allocatore per gestire l'archiviazione.
const_iterator	Tipo di un iteratore costante per la sequenza controllata.
const_local_iterator	Tipo di un iteratore di bucket costante per la sequenza controllata.
const_pointer	Tipo di un puntatore costante a un elemento.
const_reference	Tipo di un riferimento costante a un elemento.
difference_type	Tipo di una distanza Signed tra due elementi.
hasher	Tipo della funzione hash.
iterator	Tipo di un iteratore per la sequenza controllata.
key_equal	Tipo della funzione di confronto.
key_type	Tipo di una chiave di ordinamento.
local_iterator	Tipo di un iteratore di bucket per la sequenza controllata.
mapped_type	Tipo di un valore mappato associato a ogni chiave.
pointer	Tipo di un puntatore a un elemento.
reference	Tipo di un riferimento a un elemento.
size_type	Tipo di una distanza Unsigned tra due elementi.
value_type	Tipo di un elemento.

Costruttori pubblici

Nome	Descrizione
concurrent_unordered_map	Con overload. Costruisce una mappa non ordinata simultanea.

Metodi pubblici

Nome	Descrizione
at	Con overload. Trova un elemento in un concurrent_unordered_map oggetto con un valore di chiave specificato. Questo metodo è indipendente dalla concorrenza.
hash_function	Ottiene l'oggetto della funzione hash archiviato.
insert	Con overload. Aggiunge elementi all'oggetto concurrent_unordered_map .
key_eq	Ottiene l'oggetto funzione di confronto di uguaglianza archiviato.
swap	Scambia il contenuto di due concurrent_unordered_map oggetti. Questo metodo non è sicuro per la concorrenza.
unsafe_erase	Con overload. Rimuove gli elementi da in corrispondenza delle concurrent_unordered_map posizioni specificate. Questo metodo non è sicuro per la concorrenza.

Operatori pubblici

Nome	Descrizione
operator[]	Con overload. Trova o inserisce un elemento con la chiave specificata. Questo metodo è indipendente dalla concorrenza.
operator=	Con overload. Assegna il contenuto di un altro concurrent_unordered_map oggetto a questo oggetto. Questo metodo non è sicuro per la concorrenza.

Osservazioni:

Per informazioni dettagliate sulla concurrent_unordered_map classe , vedere Contenitori e oggetti paralleli.

Gerarchia di ereditarietà

_Traits

_Concurrent_hash

concurrent_unordered_map

Requisiti

Intestazione: concurrent_unordered_map.h

Spazio dei nomi: Concurrency

alle

Trova un elemento in un concurrent_unordered_map oggetto con un valore di chiave specificato. Questo metodo è indipendente dalla concorrenza.

mapped_type& at(const key_type& KVal);

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

Parametri

KVal
Valore di chiave da trovare.

Valore restituito

Riferimento al valore dei dati dell'elemento trovato.

Osservazioni:

Se il valore della chiave dell'argomento non è presente, tramite la funzione viene generato un oggetto di classe out_of_range.

begin

Restituisce un iteratore che punta al primo elemento del contenitore simultaneo. Questo metodo è sicuro per la concorrenza.

iterator begin();

const_iterator begin() const;

Valore restituito

Iteratore al primo elemento del contenitore simultaneo.

cbegin

Restituisce un iteratore const che punta al primo elemento nel contenitore simultaneo. Questo metodo è sicuro per la concorrenza.

const_iterator cbegin() const;

Valore restituito

Iteratore const al primo elemento del contenitore simultaneo.

cend

Restituisce un iteratore const che punta alla posizione successiva all'ultimo elemento nel contenitore simultaneo. Questo metodo è sicuro per la concorrenza.

const_iterator cend() const;

Valore restituito

Iteratore const alla posizione successiva all'ultimo elemento nel contenitore simultaneo.

clear

Cancella tutti gli elementi nel contenitore simultaneo. Questa funzione non è sicura per la concorrenza.

void clear();

concurrent_unordered_map

Costruisce una mappa non ordinata simultanea.

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

Parametri

_Iteratore
Tipo di iteratore di input.

_Number_of_buckets
Numero iniziale di bucket per questa mappa non ordinata.

_Hasher
Funzione hash per questa mappa non ordinata.

key_equality
Funzione di confronto di uguaglianza per questa mappa non ordinata.

_Allocatore
Allocatore per questa mappa non ordinata.

_Cominciare
Posizione del primo elemento nell'intervallo di elementi da copiare.

_Fine
Posizione del primo elemento oltre l'intervallo di elementi da copiare.

_Umap
Oggetto concurrent_unordered_map di origine da cui copiare o spostare elementi.

Osservazioni:

Tramite tutti i costruttori viene archiviato un oggetto allocatore _Allocator e viene inizializzata la mappa non ordinata.

Tramite il primo costruttore viene specificata una mappa iniziale vuota e vengono indicati in modo esplicito il numero di bucket, la funzione hash, la funzione di uguaglianza e il tipo di allocatore da utilizzare.

Tramite il secondo costruttore viene specificato un allocatore per la mappa non ordinata.

Il terzo costruttore specifica i valori forniti dall'intervallo di iteratori [ _Begin, _End).

Tramite il quarto e il quinto costruttore viene specificata una copia della mappa non ordinata simultanea _Umap.

Tramite l'ultimo costruttore viene specificato uno spostamento della mappa non ordinata simultanea _Umap.

numero

Conta il numero di elementi corrispondenti a una chiave specificata. Questa funzione è sicura per la concorrenza.

size_type count(const key_type& KVal) const;

Parametri

KVal
Chiave da ricercare.

Valore restituito

Numero di volte in cui la chiave viene visualizzata nel contenitore.

empty

Verifica se sono presenti o meno degli elementi. Questo metodo è sicuro per la concorrenza.

bool empty() const;

Valore restituito

true se il contenitore simultaneo è vuoto, false in caso contrario.

Osservazioni:

In presenza di inserimenti simultanei, il fatto che il contenitore simultaneo sia vuoto può cambiare immediatamente dopo aver chiamato questa funzione, prima che il valore restituito venga anche letto.

end

Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento nel contenitore simultaneo. Questo metodo è sicuro per la concorrenza.

iterator end();

const_iterator end() const;

Valore restituito

Iteratore nella posizione successiva all'ultimo elemento nel contenitore simultaneo.

equal_range

Trova un intervallo che corrisponde a una chiave specificata. Questa funzione è sicura per la concorrenza.

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

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

Parametri

KVal
Valore della chiave da cercare.

Valore restituito

Coppia in cui il primo elemento è un iteratore all'inizio e il secondo elemento è un iteratore alla fine dell'intervallo.

Osservazioni:

È possibile che gli inserimenti simultanei causi l'inserimento di chiavi aggiuntive dopo l'iteratore iniziale e prima dell'iteratore finale.

find

Trova un elemento che corrisponde a una chiave specificata. Questa funzione è sicura per la concorrenza.

iterator find(const key_type& KVal);

const_iterator find(const key_type& KVal) const;

Parametri

KVal
Valore della chiave da cercare.

Valore restituito

Iteratore che punta alla posizione del primo elemento che corrisponde alla chiave specificata o all'iteratore end() se tale elemento non esiste.

get_allocator

Restituisce l'oggetto allocatore archiviato per questo contenitore simultaneo. Questo metodo è sicuro per la concorrenza.

allocator_type get_allocator() const;

Valore restituito

Oggetto allocatore archiviato per questo contenitore simultaneo.

hash_function

Ottiene l'oggetto della funzione hash archiviato.

hasher hash_function() const;

Valore restituito

Oggetto della funzione hash archiviato.

insert

Aggiunge elementi all'oggetto 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);

Parametri

_Iteratore
Tipo di iteratore utilizzato per l'inserimento.

V
Tipo del valore inserito nella mappa.

value
Valore da inserire.

_Dove
Posizione iniziale in corrispondenza della quale cercare un punto di inserimento.

first
Inizio dell'intervallo da inserire.

last
Fine dell'intervallo da inserire.

Valore restituito

Coppia che contiene un iteratore e un valore booleano. Per altre informazioni, vedere le sezione Osservazioni.

Osservazioni:

La prima funzione membro determina se nella sequenza esiste un elemento X la cui chiave ha un ordinamento equivalente a quello di value. In caso contrario, crea tale elemento X e lo inizializza con value. La funzione determina quindi l'iteratore where che designa X. Se si è verificato un inserimento, la funzione restituisce std::pair(where, true). In caso contrario, viene restituito std::pair(where, false).

La seconda funzione membro restituisce insert( value), usando _Where come posizione iniziale all'interno della sequenza controllata per cercare il punto di inserimento.

La terza funzione membro inserisce la sequenza di valori degli elementi dall'intervallo [ first, last).

Il comportamento delle ultime due funzioni membro è uguale a quello delle prime due, con la differenza che value viene utilizzato per costruire il valore inserito.

key_eq

Ottiene l'oggetto funzione di confronto di uguaglianza archiviato.

key_equal key_eq() const;

Valore restituito

Oggetto funzione di confronto di uguaglianza archiviato.

load_factor

Calcola e restituisce il fattore di carico corrente del contenitore. Il fattore di carico è il numero di elementi nel contenitore diviso per il numero di bucket.

float load_factor() const;

Valore restituito

Fattore di carico per il contenitore.

max_load_factor

Ottiene o imposta il fattore di carico massimo del contenitore. Il fattore di carico massimo è il numero massimo di elementi che può essere in qualsiasi bucket prima che il contenitore cresca la tabella interna.

float max_load_factor() const;

void max_load_factor(float _Newmax);

Parametri

_Newmax

Valore restituito

La prima funzione membro restituisce il fattore di carico massimo archiviato. La seconda funzione membro non restituisce un valore ma genera un'eccezione out_of_range se il fattore di carico fornito non è valido.

max_size

Restituisce la dimensione massima del contenitore simultaneo, determinata dall'allocatore. Questo metodo è sicuro per la concorrenza.

size_type max_size() const;

Valore restituito

Numero massimo di elementi che possono essere inseriti in questo contenitore simultaneo.

Osservazioni:

Questo valore limite superiore può effettivamente essere superiore a quello che il contenitore può effettivamente contenere.

operator[]

Trova o inserisce un elemento con la chiave specificata. Questo metodo è indipendente dalla concorrenza.

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

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

Parametri

KVal
Valore della chiave da

trovare o inserire.

Valore restituito

Riferimento al valore dei dati dell'elemento trovato o inserito.

Osservazioni:

Se non viene trovato il valore della chiave dell'argomento, viene inserito insieme al valore predefinito del tipo di dati.

operator[] può essere utilizzato per inserire elementi in una mappa m utilizzando m[key] = DataValue;, dove DataValue è il valore di mapped_type dell'elemento con un valore della chiave pari a key.

Quando si utilizza operator[] per inserire gli elementi, il riferimento restituito non indica se un inserimento modifica un elemento già esistente o ne crea uno nuovo. Le funzioni find membro e insert possono essere utilizzate per determinare se un elemento con una chiave specificata è già presente prima di un inserimento.

operator=

Assegna il contenuto di un altro concurrent_unordered_map oggetto a questo oggetto. Questo metodo non è sicuro per la concorrenza.

concurrent_unordered_map& operator= (const concurrent_unordered_map& _Umap);

concurrent_unordered_map& operator= (concurrent_unordered_map&& _Umap);

Parametri

_Umap
Oggetto concurrent_unordered_map di origine.

Valore restituito

Riferimento a questo concurrent_unordered_map oggetto.

Osservazioni:

Dopo l'eliminazione di tutti gli elementi esistenti, tramite operator= il contenuto di _Umap viene copiato o spostato nel vettore simultaneo.

centone

Ricompila la tabella hash.

void rehash(size_type _Buckets);

Parametri

_Secchi
Numero desiderato di bucket.

Osservazioni:

La funzione membro modifica il numero di bucket in modo da essere almeno pari a _Buckets e ricompila la tabella hash in base alle esigenze. Il numero di bucket deve essere una potenza di 2. Se non è una potenza di 2, verrà arrotondato fino alla prossima potenza più grande di 2.

Genera un'eccezione out_of_range se il numero di bucket non è valido (0 o maggiore del numero massimo di bucket).

size

Restituisce il numero di elementi in questo contenitore simultaneo. Questo metodo è sicuro per la concorrenza.

size_type size() const;

Valore restituito

Numero di elementi presenti nel contenitore.

Osservazioni:

In presenza di operazioni di inserimento simultanee, il numero di elementi presenti nel contenitore simultaneo potrebbe cambiare immediatamente dopo la chiamata a questa funzione, prima che il valore restituito venga letto.

scambio

Scambia il contenuto di due concurrent_unordered_map oggetti. Questo metodo non è sicuro per la concorrenza.

void swap(concurrent_unordered_map& _Umap);

Parametri

_Umap
Oggetto concurrent_unordered_map con cui eseguire lo scambio.

unsafe_begin

Restituisce un iteratore al primo elemento di questo contenitore per un bucket specifico.

local_iterator unsafe_begin(size_type _Bucket);

const_local_iterator unsafe_begin(size_type _Bucket) const;

Parametri

_Secchio
Indice del bucket.

Valore restituito

Iteratore che punta all'inizio del bucket.

unsafe_bucket

Restituisce l'indice del bucket a cui viene eseguito il mapping di una chiave specifica in questo contenitore.

size_type unsafe_bucket(const key_type& KVal) const;

Parametri

KVal
Chiave dell'elemento da cercare.

Valore restituito

Indice del bucket per la chiave in questo contenitore.

unsafe_bucket_count

Restituisce il numero corrente di bucket in questo contenitore.

size_type unsafe_bucket_count() const;

Valore restituito

Numero corrente di bucket in questo contenitore.

unsafe_bucket_size

Restituisce il numero di elementi in un bucket specifico di questo contenitore.

size_type unsafe_bucket_size(size_type _Bucket);

Parametri

_Secchio
Bucket da cercare.

Valore restituito

Numero corrente di bucket in questo contenitore.

unsafe_cbegin

Restituisce un iteratore al primo elemento di questo contenitore per un bucket specifico.

const_local_iterator unsafe_cbegin(size_type _Bucket) const;

Parametri

_Secchio
Indice del bucket.

Valore restituito

Iteratore che punta all'inizio del bucket.

unsafe_cend

Restituisce un iteratore alla posizione successiva all'ultimo elemento in un bucket specifico.

const_local_iterator unsafe_cend(size_type _Bucket) const;

Parametri

_Secchio
Indice del bucket.

Valore restituito

Iteratore che punta all'inizio del bucket.

unsafe_end

Restituisce un iteratore all'ultimo elemento in questo contenitore per un bucket specifico.

local_iterator unsafe_end(size_type _Bucket);

const_local_iterator unsafe_end(size_type _Bucket) const;

Parametri

_Secchio
Indice del bucket.

Valore restituito

Iteratore che punta alla fine del bucket.

unsafe_erase

Rimuove gli elementi da in corrispondenza delle concurrent_unordered_map posizioni specificate. Questo metodo non è sicuro per la concorrenza.

iterator unsafe_erase(
    const_iterator _Where);

iterator unsafe_erase(
    const_iterator _Begin,
    const_iterator _End);

size_type unsafe_erase(
    const key_type& KVal);

Parametri

_Dove
Posizione dell'iteratore da cui cancellare.

_Cominciare
Posizione del primo elemento nell'intervallo di elementi da cancellare.

_Fine
Posizione del primo elemento oltre l'intervallo di elementi da cancellare.

KVal
Valore della chiave da cancellare.

Valore restituito

Le prime due funzioni membro restituiscono un iteratore che designa il primo elemento rimanente oltre qualsiasi elemento rimosso o concurrent_unordered_map::end() se tale elemento non esiste. La terza funzione membro restituisce il numero di elementi rimossi.

Osservazioni:

Tramite la prima funzione membro viene rimosso l'elemento della sequenza controllata puntata da _Where. La seconda funzione membro rimuove gli elementi nell'intervallo [ _Begin, _End).

La terza funzione membro rimuove gli elementi nell'intervallo delimitato da concurrent_unordered_map::equal_range(KVal).

unsafe_max_bucket_count

Restituisce il numero massimo di bucket in questo contenitore.

size_type unsafe_max_bucket_count() const;

Valore restituito

Numero massimo di bucket in questo contenitore.

Vedi anche

Spazio dei nomi concurrency
Contenitori e oggetti paralleli