concurrent_unordered_map Clase

La clase concurrent_unordered_map es un contenedor seguro para simultaneidad que controla una secuencia de variación de longitud de elementos del tipo std::pair<const K, _Element_type>. La secuencia se representa de una manera que habilita la anexión segura para simultaneidad, el acceso a elementos, el acceso a iterador y las operaciones de recorrido de iterador. Aquí, seguro para la concurrencia significa que los punteros e iteradores siempre son válidos. No es una garantía de inicialización de elementos ni de un orden de recorrido determinado.

Sintaxis

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

Parámetros

K
El tipo de clave.

_Element_type
El tipo mapeado.

_Hasher
El tipo de objeto de la función hash. Este argumento es opcional y el valor predeterminado es std::hash<K>.

key_equality
El tipo de objeto de función de comparación de igualdad. Este argumento es opcional y el valor predeterminado es std::equal_to<K>.

_Allocator_type
El tipo que representa el objeto de asignador almacenado que encapsula los detalles sobre la asignación y desasignación de memoria para el mapa desordenado concurrente. Este argumento es opcional y el valor predeterminado es std::allocator<std::pair<K, _Element_type>>.

Miembros

Definiciones de tipos públicas

Nombre	Descripción
allocator_type	El tipo de un asignador para administrar el almacenamiento.
const_iterator	El tipo de un iterador constante para la secuencia controlada.
const_local_iterator	El tipo de un iterador constante de cubo para la secuencia controlada.
const_pointer	El tipo de un puntero constante a un elemento.
const_reference	El tipo de una referencia constante a un elemento.
difference_type	El tipo de una distancia con signo entre dos elementos.
hasher	El tipo de la función hash.
iterator	El tipo de un iterador para la secuencia controlada.
key_equal	El tipo de la función de comparación.
key_type	El tipo de una clave de ordenación.
local_iterator	El tipo de un iterador de cubeta para la secuencia controlada.
mapped_type	El tipo de un valor mapeado asociado a cada clave.
pointer	El tipo de un puntero a un elemento.
reference	El tipo de una referencia a un elemento.
size_type	El tipo de una distancia sin signo entre dos elementos.
value_type	El tipo de un elemento.

Constructores públicos

Nombre	Descripción
concurrent_unordered_map	Sobrecargado Construye un mapa desordenado concurrente.

Métodos públicos

Nombre	Descripción
en	Sobrecargado Busca un elemento en un concurrent_unordered_map con un valor de clave especificado. Este método es seguro para simultaneidad.
hash_function	Obtiene el objeto de función hash almacenado.
insertar	Sobrecargado Agrega elementos al objeto concurrent_unordered_map.
key_eq	Obtiene el objeto de función de comparación de igualdad almacenado.
swap	Intercambia el contenido de dos objetos concurrent_unordered_map. Este método no es seguro para la simultaneidad.
unsafe_erase	Sobrecargado Quita los elementos de concurrent_unordered_map en las posiciones especificadas. Este método no es seguro para la simultaneidad.

Operadores públicos

Nombre	Descripción
operador []	Sobrecargado Busca o inserta un elemento con la clave especificada. Este método es seguro para simultaneidad.
operador =	Sobrecargado Asigna el contenido de otro objeto concurrent_unordered_map a este. Este método no es seguro para la simultaneidad.

Comentarios

Para obtener más información acerca de la clase concurrent_unordered_map, consulte Contenedores y objetos paralelos.

Jerarquía de herencia

_Traits

_Concurrent_hash

concurrent_unordered_map

Requisitos

Encabezado: concurrent_unordered_map.h

Espacio de nombres: simultaneidad

en

Busca un elemento en un concurrent_unordered_map con un valor de clave especificado. Este método es seguro para simultaneidad.

mapped_type& at(const key_type& KVal);

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

Parámetros

KVal
Valor de clave a buscar.

Valor devuelto

Una referencia al valor de datos del elemento encontrado.

Comentarios

Si el valor de clave de argumento no se encuentra, la función produce un objeto de clase out_of_range.

empezar

Devuelve un iterador que apunta al primer elemento del contenedor simultáneo. Este método es seguro para simultaneidad.

iterator begin();

const_iterator begin() const;

Valor devuelto

Iterador al primer elemento del contenedor concurrente.

cbegin

Devuelve un iterador constante que apunta al primer elemento del contenedor concurrente. Este método es seguro para simultaneidad.

const_iterator cbegin() const;

Valor devuelto

Iterador constante al primer elemento del contenedor simultáneo.

cend

Devuelve un iterador constante que apunta a la ubicación que sigue al último elemento del contenedor simultáneo. Este método es seguro para simultaneidad.

const_iterator cend() const;

Valor devuelto

Iterador constante a la posición que sigue al último elemento del contenedor simultáneo.

eliminar

Borra todos los elementos del contenedor concurrente. Esta función no es segura para la simultaneidad.

void clear();

concurrent_unordered_map

Construye un mapa desordenado concurrente.

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

Parámetros

_Iterador
El tipo de iterador de entrada.

_Number_of_buckets
El número inicial de buckets para este mapa no ordenado.

_Hasher
La función hash de este mapa no ordenado.

key_equality
La función de comparación de igualdad para este mapa no ordenado.

_Asignador
El allocador para este mapa no ordenado.

_Empezar
Posición del primer elemento en el intervalo de elementos que se va a copiar.

_Fin
Posición del primer elemento más allá del intervalo de elementos que se va a copiar.

_Umap
El objeto de origen concurrent_unordered_map del que copiar o mover elementos.

Comentarios

Todos los constructores almacenan un objeto de asignador _Allocator e inicializan el mapa no ordenado.

El primer constructor especifica un mapa inicial vacío y especifica explícitamente la cantidad de cubos, la función hash, la función de igualdad y el tipo de asignador que se van a usar.

El segundo constructor especifica un asignador para el mapa no ordenado.

El tercer constructor especifica los valores proporcionados por el intervalo del iterador [ _Begin, _End).

Los constructores cuarto y quinto especifican una copia del mapa no ordenado concurrente _Umap.

El último constructor especifica un traslado del mapa no ordenado concurrente _Umap.

Recuento

Cuenta el número de elementos que coinciden con una clave especificada. Esta función es segura para la concurrencia.

size_type count(const key_type& KVal) const;

Parámetros

KVal
La clave a buscar.

Valor devuelto

Número de veces que aparece la clave en el contenedor.

vacío

Comprueba si no hay ningún elemento presente. Este método es seguro para simultaneidad.

bool empty() const;

Valor devuelto

Es true si el contenedor simultáneo está vacío; de lo contrario, es false.

Comentarios

En presencia de inserciones simultáneas, el estado del contenedor concurrente (vacío o no) puede cambiar inmediatamente después de llamar a esta función, incluso antes de que se lea el valor devuelto.

fin

Devuelve un iterador que apunta a la ubicación que sigue al último elemento del contenedor concurrente. Este método es seguro para simultaneidad.

iterator end();

const_iterator end() const;

Valor devuelto

Iterador a la ubicación que sigue al último elemento del contenedor simultáneo.

Intervalo_igual

Busca el intervalo que coincide con una clave especificada. Esta función es segura para la concurrencia.

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

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

Parámetros

KVal
Valor de clave que se va a buscar.

Valor devuelto

Un par donde el primer elemento es un iterador al principio del intervalo y el segundo elemento es un iterador al final del intervalo.

Comentarios

Es posible que las inserciones simultáneas provoquen que se inserten claves adicionales después del iterador inicial y antes del iterador final.

encontrar

Busca un elemento que coincide con una clave especificada. Esta función es segura para la concurrencia.

iterator find(const key_type& KVal);

const_iterator find(const key_type& KVal) const;

Parámetros

KVal
Valor de clave que se va a buscar.

Valor devuelto

Iterador que apunta a la ubicación del primer elemento que coincide con la clave proporcionada, o el iterador end() si no existe dicho elemento.

get_allocator

Devuelve el objeto de asignador almacenado para este contenedor simultáneo. Este método es seguro para simultaneidad.

allocator_type get_allocator() const;

Valor devuelto

El objeto de asignador almacenado para este contenedor simultáneo.

función hash

Obtiene el objeto de función hash almacenado.

hasher hash_function() const;

Valor devuelto

Objeto de función hash almacenado.

insertar

Agrega elementos al objeto 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);

Parámetros

_Iterador
Tipo de iterador utilizado para la inserción.

V
El tipo del valor insertado en el mapa.

valor
Valor que se va a insertar.

_Dónde
Ubicación inicial para buscar un punto de inserción.

primero
Inicio del intervalo a insertar.

último
Final del intervalo que se va a insertar.

Valor devuelto

Un par que contiene un iterador y un valor booleano. Para obtener información más detallada, consulte la sección Comentarios.

Comentarios

La primera función miembro determina si existe un elemento X en la secuencia cuya clave tiene un orden equivalente al de value. Si no es así, crea un elemento X de este tipo y lo inicializa con value. A continuación, la función determina el iterador where que designa X. Si se ha producido una inserción, la función devuelve std::pair(where, true). De lo contrario, devuelve std::pair(where, false).

La segunda función miembro devuelve insert(value), utilizando _Where como un lugar inicial dentro de la secuencia controlada para buscar el punto de inserción.

La tercera función miembro inserta la secuencia de valores de elementos del intervalo [first, last).

Las dos últimas funciones miembro se comportan igual que las dos primeras, salvo que value se usa para construir el valor insertado.

key_eq

Obtiene el objeto de función de comparación de igualdad almacenado.

key_equal key_eq() const;

Valor devuelto

El objeto de función de comparación de igualdad almacenado.

factor_de_carga

Calcula y devuelve el factor de carga actual del contenedor. El factor de carga es el número de elementos en el contenedor dividido por el número de cubos.

float load_factor() const;

Valor devuelto

Factor de carga del contenedor.

factor_de_carga_máximo

Obtiene o establece el factor de carga máximo del contenedor. El factor de carga máximo es el número mayor de elementos que pueden estar en cualquier cubo antes de que crezca la tabla interna del contenedor.

float max_load_factor() const;

void max_load_factor(float _Newmax);

Parámetros

_Newmax

Valor devuelto

La primera función miembro devuelve el factor de carga máxima almacenado. La segunda función miembro no devuelve un valor, pero produce una excepción de out_of_range si el factor de carga proporcionado no es válido.

tamaño_máximo

Devuelve el tamaño máximo del contenedor simultáneo, determinado por el asignador. Este método es seguro para simultaneidad.

size_type max_size() const;

Valor devuelto

Número máximo de elementos que se pueden insertar en este contenedor simultáneo.

Comentarios

Este valor de límite superior puede ser más alto que lo que en realidad puede contener el contenedor.

operador[]

Busca o inserta un elemento con la clave especificada. Este método es seguro para simultaneidad.

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

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

Parámetros

KVal
El valor clave para

buscar o insertar

Valor devuelto

Referencia al valor de datos del elemento encontrado o insertado.

Comentarios

Si el valor de clave de argumento no se encuentra, se inserta junto con el valor predeterminado del tipo de datos.

Se puede usar operator[] para insertar elementos en un mapa m mediante m[key] = DataValue;, donde DataValue es el valor de mapped_type del elemento con un valor de clave de key.

Cuando se emplea operator[] para insertar elementos, la referencia devuelta no indica si una inserción cambia un elemento ya existente o crea uno nuevo. Se pueden usar las funciones miembro find e insert para determinar si ya existe un elemento con una clave especificada antes de una inserción.

operador =

Asigna el contenido de otro objeto concurrent_unordered_map a este. Este método no es seguro para la simultaneidad.

concurrent_unordered_map& operator= (const concurrent_unordered_map& _Umap);

concurrent_unordered_map& operator= (concurrent_unordered_map&& _Umap);

Parámetros

_Umap
Objeto concurrent_unordered_map de origen.

Valor devuelto

Una referencia a este objeto concurrent_unordered_map.

Comentarios

Después de borrar los elementos existentes de un vector simultáneo, operator= copia o mueve el contenido de _Umap al vector simultáneo.

refrito

Reconstruye la tabla hash.

void rehash(size_type _Buckets);

Parámetros

_Buckets
Número deseado de cubos.

Comentarios

La función miembro altera el número de cubetas para que sean al menos _Buckets y vuelve a generar la tabla hash según sea necesario. El número de contenedores debe ser una potencia de 2. Si no es una potencia de 2, se redondeará a la siguiente potencia más grande de 2.

Produce una excepción out_of_range si el número de cubos no es válido (ya sea 0 o mayor que el número máximo de cubos).

tamaño

Devuelve el número de elementos de este contenedor simultáneo. Este método es seguro para simultaneidad.

size_type size() const;

Valor devuelto

Número de elementos del contenedor.

Comentarios

En presencia de inserciones simultáneas, el número de elementos del contenedor simultáneo puede cambiar inmediatamente después de llamar a esta función, antes de que se lea el valor devuelto.

intercambio

Intercambia el contenido de dos objetos concurrent_unordered_map. Este método no es seguro para la simultaneidad.

void swap(concurrent_unordered_map& _Umap);

Parámetros

_Umap
Objeto concurrent_unordered_map que se va a intercambiar.

Comienzo_inseguro

Devuelve un iterador al primer elemento de este contenedor para un cubo específico.

local_iterator unsafe_begin(size_type _Bucket);

const_local_iterator unsafe_begin(size_type _Bucket) const;

Parámetros

_Cubo
Índice del bucket.

Valor devuelto

Iterador que apunta al principio del cubo.

cubo_inseguro

Devuelve el índice del cubo al que se asigna una clave específica en este contenedor.

size_type unsafe_bucket(const key_type& KVal) const;

Parámetros

KVal
Clave del elemento que se busca.

Valor devuelto

Índice del bucket para la clave en este contenedor.

conteo_de_cubos_inseguros

Devuelve el número actual de buckets en este contenedor.

size_type unsafe_bucket_count() const;

Valor devuelto

Número actual de cubos en este contenedor.

tamaño_de_cubo_inseguro

Devuelve el número de elementos de un cubo específico de este contenedor.

size_type unsafe_bucket_size(size_type _Bucket);

Parámetros

_Cubo
El cubo que se va a encontrar.

Valor devuelto

Número actual de cubos en este contenedor.

unsafe_cbegin

Devuelve un iterador al primer elemento de este contenedor para un cubo específico.

const_local_iterator unsafe_cbegin(size_type _Bucket) const;

Parámetros

_Bucket
Índice del cubo.

Valor devuelto

Iterador que apunta al principio del cubo.

unsafe_cend

Devuelve un iterador a la ubicación que sigue al último elemento en un cubo determinado.

const_local_iterator unsafe_cend(size_type _Bucket) const;

Parámetros

_Bucket
Índice del cubo.

Valor devuelto

Iterador que apunta al principio del cubo.

unsafe_end

Devuelve un iterador al último elemento de este contenedor para un cubo específico.

local_iterator unsafe_end(size_type _Bucket);

const_local_iterator unsafe_end(size_type _Bucket) const;

Parámetros

_Cubo
Índice del bucket.

Valor devuelto

Iterador que apunta al final de la cubeta.

borrado_inseguro

Quita los elementos de concurrent_unordered_map en las posiciones especificadas. Este método no es seguro para la simultaneidad.

iterator unsafe_erase(
    const_iterator _Where);

iterator unsafe_erase(
    const_iterator _Begin,
    const_iterator _End);

size_type unsafe_erase(
    const key_type& KVal);

Parámetros

_Dónde
La posición del iterador en la que borrar.

_Empezar
Posición del primer elemento en el intervalo de elementos que se va a borrar.

_Fin
Posición del primer elemento justo después del rango de elementos que se va a borrar.

KVal
Valor de clave que se va a borrar.

Valor devuelto

Las dos primeras funciones miembro devuelven un iterador que designa el primer elemento que permanece más allá de los elementos quitados, o concurrent_unordered_map::end() si no existe ese elemento. La tercera función miembro devuelve el número de elementos que elimina.

Comentarios

La primera función miembro elimina el elemento de la secuencia controlada a la que apunta _Where. La segunda función miembro quita los elementos del intervalo [ _Begin, _End).

La tercera función miembro elimina los elementos del intervalo delimitado por concurrent_unordered_map::equal_range(KVal).

conteo_maximo_de_buckets_inseguros

Devuelve el número máximo de cubos de este contenedor.

size_type unsafe_max_bucket_count() const;

Valor devuelto

Número máximo de cubos de este contenedor.

Consulte también

espacio de nombres de concurrencia
Contenedores y objetos paralelos