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 simultaneidad significa que los punteros e iteradores siempre son válidos. No es una garantía de inicialización de elementos ni de un orden transversal determinado.
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
El tipo de clave.
_Element_type
El tipo asignado.
_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 de la asignación desordenada simultánea. Este argumento es opcional y el valor predeterminado es std::allocator<std::pair<K, _Element_type>>.
| 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 de depósito constante 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 depósito para la secuencia controlada. |
mapped_type |
El tipo de un valor asignado 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. |
| Nombre | Descripción |
|---|---|
| concurrent_unordered_map | Con sobrecarga. Construye una asignación desordenada simultánea. |
| Nombre | Descripción |
|---|---|
| at | Con sobrecarga. 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. |
| insert | Con sobrecarga. 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 | Con sobrecarga. Quita los elementos de concurrent_unordered_map en las posiciones especificadas. Este método no es seguro para la simultaneidad. |
| Nombre | Descripción |
|---|---|
| operator[] | Con sobrecarga. Busca o inserta un elemento con la clave especificada. Este método es seguro para simultaneidad. |
| operator= | Con sobrecarga. Asigna el contenido de otro objeto concurrent_unordered_map a este. Este método no es seguro para la simultaneidad. |
Para obtener más información acerca de la clase concurrent_unordered_map, consulte Contenedores y objetos paralelos.
_Traits
_Concurrent_hash
concurrent_unordered_map
Encabezado: concurrent_unordered_map.h
Espacio de nombres: simultaneidad
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;
KVal
Valor de clave que se va a buscar.
Una referencia al valor de datos del elemento encontrado.
Si el valor de clave de argumento no se encuentra, la función produce un objeto de clase out_of_range.
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;
Iterador al primer elemento del contenedor simultáneo.
Devuelve un iterador constante que apunta al primer elemento del contenedor simultáneo. Este método es seguro para simultaneidad.
const_iterator cbegin() const;
Iterador constante al primer elemento del contenedor simultáneo.
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;
Iterador constante a la ubicación que sigue al último elemento del contenedor simultáneo.
Borra todos los elementos del contenedor simultáneo. Esta función no es segura para la simultaneidad.
void clear();
Construye una asignación desordenada simultánea.
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);
_Iterator
El tipo de iterador de entrada.
_Number_of_buckets
El número inicial de cubos para esta asignación no ordenada.
_Hasher
La función hash de esta asignación no ordenada.
key_equality
La función de comparación de igualdad de esta asignación no ordenada.
_Allocator
El asignador de esta asignación no ordenada.
_Begin
Posición del primer elemento en el intervalo de elementos que se va a copiar.
_End
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.
Todos los constructores almacenan un objeto de asignador _Allocator e inicializan la asignación no ordenada.
El primer constructor especifica una asignación inicial vacía y especifica explícitamente el número 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 la asignación no ordenada.
El tercer constructor especifica los valores proporcionados por el intervalo del iterador [ _Begin, _End).
Los constructores cuarto y quinto especifican una copia de la asignación simultánea no ordenada _Umap.
El último constructor especifica un movimiento de la asignación simultánea no ordenada _Umap.
Cuenta el número de elementos que coinciden con una clave especificada. Este método es seguro para simultaneidad.
size_type count(const key_type& KVal) const;
KVal
Clave que se va a buscar.
Número de veces que aparece la clave en el contenedor.
Comprueba si no hay ningún elemento presente. Este método es seguro para simultaneidad.
bool empty() const;
Es true si el contenedor simultáneo está vacío; de lo contrario, es false.
En presencia de inserciones simultáneas, tanto si el contenedor simultáneo está vacío como si no puede cambiar inmediatamente después de llamar a esta función, antes de que se lea el valor devuelto.
Devuelve un iterador que apunta a la ubicación que sigue al último elemento del contenedor simultáneo. Este método es seguro para simultaneidad.
iterator end();
const_iterator end() const;
Iterador a la ubicación que sigue al último elemento del contenedor simultáneo.
Busca el intervalo que coincide con una clave especificada. Este método es seguro para simultaneidad.
std::pair<iterator,
iterator> equal_range(
const key_type& KVal);
std::pair<const_iterator,
const_iterator> equal_range(
const key_type& KVal) const;
KVal
Valor de clave que se va a buscar.
Un par donde el primer elemento es un iterador al principio del intervalo y el segundo elemento es un iterador al final del intervalo.
Es posible que las inserciones simultáneas provoquen que se inserte más claves después del iterador inicial y antes del iterador final.
Busca un elemento que coincide con una clave especificada. Este método es seguro para simultaneidad.
iterator find(const key_type& KVal);
const_iterator find(const key_type& KVal) const;
KVal
Valor de clave que se va a buscar.
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.
Devuelve el objeto de asignador almacenado para este contenedor simultáneo. Este método es seguro para simultaneidad.
allocator_type get_allocator() const;
El objeto de asignador almacenado para este contenedor simultáneo.
Obtiene el objeto de función hash almacenado.
hasher hash_function() const;
Objeto de función hash almacenado.
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);
_Iterator
Tipo de iterador utilizado para la inserción.
V
El tipo del valor insertado en la asignación.
value
Valor que se va a insertar.
_Where
Ubicación inicial para buscar un punto de inserción.
first
Comienzo del intervalo que se va a insertar.
last
Final del intervalo que se va a insertar.
Un par que contiene un iterador y un valor booleano. Para obtener información más detallada, consulte la sección 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), con _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.
Obtiene el objeto de función de comparación de igualdad almacenado.
key_equal key_eq() const;
El objeto de función de comparación de igualdad almacenado.
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;
Factor de carga del contenedor.
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);
_Newmax
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.
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;
Número máximo de elementos que se pueden insertar en este contenedor simultáneo.
Este valor de límite superior puede ser más alto que lo que en realidad puede contener el contenedor.
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);
KVal
Valor de clave que se va a
buscar o a insertar.
Referencia al valor de datos del elemento encontrado o insertado.
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.
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);
_Umap
Objeto concurrent_unordered_map de origen.
La referencia a este objeto concurrent_unordered_map.
Después de borrar los elementos existentes de un vector simultáneo, operator= copia o mueve el contenido de _Umap al vector simultáneo.
Recompila la tabla hash.
void rehash(size_type _Buckets);
_Buckets
Número deseado de cubos.
La función miembro modifica el número de depósitos para que sea al menos _Buckets y vuelve a generar la tabla hash según sea necesario. El número de cubos 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).
Devuelve el número de elementos de este contenedor simultáneo. Este método es seguro para simultaneidad.
size_type size() const;
Número de elementos del contenedor.
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.
Intercambia el contenido de dos objetos concurrent_unordered_map. Este método no es seguro para la simultaneidad.
void swap(concurrent_unordered_map& _Umap);
_Umap
Objeto concurrent_unordered_map que se va a intercambiar.
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;
_Bucket
Índice del cubo.
Iterador que apunta al principio del cubo.
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;
KVal
Clave de elemento que se busca.
Índice de cubo de la clave de este contenedor.
Devuelve el número actual de cubos de en contenedor.
size_type unsafe_bucket_count() const;
Número actual de cubos en este contenedor.
Devuelve el número de elementos de un cubo específico de este contenedor.
size_type unsafe_bucket_size(size_type _Bucket);
_Bucket
Cubo que se va a buscar.
Número actual de cubos en este contenedor.
Devuelve un iterador al primer elemento de este contenedor para un cubo específico.
const_local_iterator unsafe_cbegin(size_type _Bucket) const;
_Bucket
Índice del cubo.
Iterador que apunta al principio del cubo.
Devuelve un iterador a la ubicación que sigue al último elemento de un cubo concreto.
const_local_iterator unsafe_cend(size_type _Bucket) const;
_Bucket
Índice del cubo.
Iterador que apunta al principio del cubo.
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;
_Bucket
Índice del cubo.
Iterador que apunta al final del cubo.
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);
_Where
La posición del iterador en la que borrar.
_Begin
Posición del primer elemento en el intervalo de elementos que se va a borrar.
_End
Posición del primer elemento después del intervalo de elementos que se va a borrar.
KVal
Valor de clave que se va a borrar.
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 se quitan.
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).
Devuelve el número máximo de cubos de este contenedor.
size_type unsafe_max_bucket_count() const;
Número máximo de cubos de este contenedor.
concurrency (espacio de nombres)
Contenedores y objetos paralelos