Requisitos denominados de C++:UnorderedAssociativeContainer(desde C++11)

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Requisitos denominados de C++

Básicos ConstruiblePorDefecto ConstruiblePorMovimiento (C++11) ConstruiblePorCopia AsignablePorCopia AsignablePorMovimiento (C++11) Destructible Props. de Tipos TipoEscalar TipoPOD TrivialmenteCopiable (C++11) TipoTrivial (C++11) TipoDeDiseñoEstándar (C++11)   TipoDeTiempoDeVidaImplícito Toda la biblioteca ComprobableBooleano ComparableEnIgualdad ComparableEnMenorQue Intercambiable IntercambiableEnValor (C++11) NullablePointer (C++11) Hash (C++11) Asignador ObjetoFunción Invocable Predicado PredicadoBinario Comparar

Contenedores Contenedor ContenedorReversible ContenedorConscienteDeAsignador ContenedorDeSecuencia ContenedorContiguo (C++17) ContenedorAsociativo ContenedorAsociativoNoOrdenado (C++11)   Elementos de contenedores InsertablePorDefecto (C++11) InsertablePorCopia (C++11) InsertablePorMovimiento (C++11) ConstruiblePorEmplazamiento (C++11) Borrable (C++11) Iteradores IteradorLegado IteradorDeEntradaLegado IteradorDeSalidaLegado IteradorDeAvanceLegado IteradorBidireccionalLegado IteradorDeAccesoAleatorioLegado IteradorContiguoLegado (C++17) IteradorConstexpr (C++20) E/S de flujos FunciónDeEntradaConFormato FunciónDeEntradaSinFormato FunciónDeSalidaConFormato FunciónDeSalidaSinFormato Formateadores FormateadorBásico (C++20) Formateador (C++20)

Números aleatorios SeedSequence (C++11) MotorDeNúmerosAleatorios (C++11) DistribuciónDeNúmerosAleatorios (C++11) GeneradorDeBitsAleatorioUniforme (C++11) AdaptadorDeMotorDeNúmerosAleatorios (C++11) Concurrencia BloqueableBásico (C++11) Bloqueable (C++11) BloqueableTemporizado (C++11) BloqueableCompartido (C++14) BloqueableTemporizadoCompartido (C++14) Mutex (C++11) MutexTemporizado (C++11) MutexCompartido (C++17) MutexTemporizadoCompartido (C++14) Rangos ObjetoAdaptadorDeRango (C++20) ObjetoCierreAdaptadorDeRango (C++20) Vista multidimensional LayoutMapping (C++23) LayoutMappingPolicy (C++23) AccessorPolicy (C++23) Otros RasgosDeCarácter RasgosDeExpresiónRegular (C++11)   TipoMáscaraDeBits TipoLiteral (C++11) TipoNumérico RasgoDeTipoUnario (C++11) RasgoDeTipoBinario (C++11) RasgoDeTransformación (C++11) Reloj (C++11) RelojTrivial (C++11)

 

Los contenedores asociativos no ordenados son Containers que permiten una búsqueda rápida de objetos en función de claves. En el peor caso la complejidad es lineal, pero en promedio es más rápida para la mayoría de las operaciones.

Los contenedores asociativos no ordenados se parametrizan mediante una Clave; Hash, un objeto de función Hash que actúa como función hash en Clave; y Pred, un BinaryPredicate que evalúa la equivalencia entres Claves. std::unordered_map y std::unordered_multimap también tienen un tipo mapeado T asociado con la Clave.

Si dos Claves son iguales de acuerdo con Pred, Hash debe devolver el mismo valor para ambas claves.

Si existen Hash::is_transparent y Pred::is_transparent y cada uno nombra un tipo, las funciones miembro find, contains, count, equal_range, y bucket aceptan argumentos de tipos distintos de Clave y esperan que Hash se pueda llamar con valores de estos tipos, y que Pred sea una función de comparación transparente como std::equal_to<>.

(desde C++20)

std::unordered_map y std::unordered_set pueden contener como máximo un elemento con una clave dada, en cambio std::unordered_multiset y std::unordered_multimap pueden tener múltiples elementos con la misma clave (que siempre deben ser adyacentes en la iteraciones).

Para std::unordered_set y std::unordered_multiset el tipo del valor es el mismo que el tipo de la clave, y iterator y const_iterator son iteradores constantes. Para std::unordered_map y std::unordered_multimap el tipo del valor es std::pair<const Key, T>.

Los elementos de un contenedor asociativo no ordenado se organizan en agrupaciones, las claves con el mismo hash terminan en el mismo contenedor. El número de agrupaciones se incrementa cuando el tamaño del contenedor aumenta para mantener la cantidad promedio de elementos en cada agrupación por debajo de un valor determinado.

El “Rehashing” invalida el iterador y puede provocar que los elementos se reorganicen en diferentes grupos, pero no invalida las referencias a los elementos.

Los contenedores asociativos no ordenados cumplen los requisitos de AllocatorAwareContainer. Para std::unordered_map y std::unordered_multimap, los requisitos de value_type en AllocatorAwareContainer se aplican a key_type y mapped_type (no a value_type).

Requisitos

Leyenda
X	Una clase de contenedor asociativo no ordenado
a	Un valor de tipo X
a2	Un valor de un tipo con nodos compatibles con el tipoX
b	Un valor de tipo X o const X
a_uniq	Un valor de tipo X cuando X soporta claves únicas
a_eq	Un valor de tipo X cuando X soporta claves equivalentes
a_tran	Un valor de tipo X o const X cuando los identificadores calificados X::key_equal::is_transparent y X::hasher::is_transparent son válidos y denotan tipos
i, j	Iteradores de entrada que hacen referencia a value_type
[i, j)	Un rango válido
rg(desde C++23)Un valor de un tipo R que modela container-compatible-range<value_type>
p, q2	Iteradores constantes válidos a a
q, q1	Iteradores constantes desreferenciables válidos a a
r	Un iterador desreferenciable válido a a
[q1, q2)	Un rango válido en a
il	Un valor de tipo std::initializer_list<value_type>
t	Un valor de tipo X::value_type
k	Un valor de tipo key_type
hf	Un valor de tipo hasher o const hasher
eqUn valor de tipo key_equal o const key_equal
ke	Un valor tal que eq(r1, ke)== eq(ke, r1), hf(r1)== hf(ke) si eq(r1, ke) es true, y si dos de eq(r1, ke), eq(r2, ke), y eq(r1, r2) son true, entonces las tres son true, donde r1 y r2 son claves de elementos en a_tran
kx(desde C++23)	Un valor tal que eq(r1, kx)== eq(kx, r1), hf(r1)== hf(kx) si eq(r1, kx) es true, si dos de eq(r1, kx), eq(r2, kx), y eq(r1, r2) son true, entonces las tres son true, y kx no es convertible ni a iterator ni a const_iterator, donde r1 y r2 son claves de los elementos en a_tran
n	Un valor de tipo size_type
z	Un valor de tipo float
nh(desde C++17)	Un r-valor de tipo X::node_type

Tipos miembro

Nombre	Tipo	Requisitos	Notas
X::key_type	Key
X::mapped_type	T	Solamente std::unordered_map y std::unordered_multimap
X::value_type	Key	Saloamente std::unordered_set y std::unordered_multiset. Erasable en X
	std::pair<const Key, T>	Solamente std::unordered_map y std::unordered_multimap. Erasable en X
X::hasher	Hash	Hash
X::key_equal	Pred	CopyConstructible; BinaryPredicate que toma dos argumentos de tipo Key y expresa una relación de equivalencia
X::local_iterator	Iterator	Categoría y tipos son los mismos que X::iterator	Se puede usar para iterar a través de un grupo, pero no a través de distintos grupos
X::const_local_iterator	Iterator	Categoría y tipos son los mismos que X::const_iterator
X::node_type(desde C++17)	Una especialización de la plantilla de clase node-handle	Los tipos anidados públicos son los mismos que los tipos correspondientes en X

Funciones miembro y operadores

Expresión	Resultado	Precondiciones	Efectos	Retorno	Complejidad
X(n, hf, eq)			Construye un contenedor vacío con al menos n agrupaciones, usando hf como función de hash y eq como predicado de igualdad de claves		O(n)
X(n, hf)		key_equal es DefaultConstructible	Construye un contenedor vacío con al menos n agrupaciones, usando hf como función de hash y key_equal() como predicado de igualdad de claves		O(n)
X(n)		hasher y key_equal son DefaultConstructible	Construye un contenedor vacío con al menos n agrupaciones, usando hasher() como función de hash y key_equal() como predicado de igualdad de claves		O(n)
X a = X(); X a;		hasher y key_equal son DefaultConstructible	Construye un contenedor vacío con un número de agrupaciones no espcificado, usando hasher() como función de hash y key_equal() como predicado de igualdad de claves		Constante
X(i, j, n, hf, eq)		value_type es EmplaceConstructible en X a partir de *i	Construye un contenedor vacío con al menos n agrupaciones, usando hf como función de hash y eq como predicado de igualdad de claves, e inserta los elementos de [i, j)		Caso promedio O(N) (N es std::distance(i, j)), peor caso O(N2)
X(i, j, n, hf)		key_equal es DefaultConstructible. value_type es EmplaceConstructible en X a partir de *i	Construye un contenedor vacío con al menos n agrupamientos, usando hf como función de hash y key_equal() como predicado de igualdad de claves, e inserta los elementos de [i, j)		Caso promedio O(N) (N es std::distance(i, j)), pero caso O(N2)
X(i, j, n)		hasher y key_equal son DefaultConstructible. value_type es EmplaceConstructible en X a partir de *i	Construye un contenedor vacío con al menos n agrupaciones, usando hasher() como la función de hash y key_equal() como el predicado de igualdad de claves, e inserta los elementos de [i, j)		Caso promedio O(N) (N es std::distance(i, j)), peor caso O(N2)
X(i, j)		hasher y key_equal son DefaultConstructible. value_type es EmplaceConstructible en X a partir de *i	Construye un contenedor vacío con un número de agrupaciones sin especificar, usando hasher() como la función de hash y key_equal() como el predicado de igualdad de claves, e inserta los elementos de [i, j)		Caso promedio O(N) (N es std::distance(i, j)), peor caso O(N2)
X(std::from_range,   rg, n, hf, eq) (desde C++23)		value_type es EmplaceConstructible en X a partir de *ranges::begin(rg)	Construye un contenedor vacío con al menos n agrupaciones, usando hf como la función de hash y eq como el predicado de igualdad de claves, e inserta elementos de rg		Caso promedio O(N) (N es ranges::distance(rg)), peor caso O(N2)
X(std::from_range,   rg, n, hf) (desde C++23)		key_equal es DefaultConstructible. value_type es EmplaceConstructible en X a partir de *ranges::begin(rg)	Construye un contenedor vacío con al menos n agrupaciones, usando hf como la función de hash y key_equal() como el predicado de igualdad de claves, e inserta elementos de rg		Caso promedio O(N) (N es ranges::distance(rg)), peor caso case O(N2)
X(std::from_range,   rg, n) (desde C++23)		hasher y key_equal son DefaultConstructible. value_type es EmplaceConstructible en X a partir de *ranges::begin(rg)	Construye un contenedor vacío con al menos n agrupaciones, usando hasher() como la función de hash y key_equal() como el predicado de igualdad de claves, e inserta elementos de rg		Caso promedio O(N) (N es ranges::distance(rg)), peor caso O(N2)
X(std::from_range,   rg) (desde C++23)		hasher y key_equal son DefaultConstructible. value_type es EmplaceConstructible en X a partir de *ranges::begin(rg)	Construye un contenedor vacío con un número de agrupaciones sin especificar, usando hasher() como a función de hash y key_equal() como el predicado de igualdad de claves, e inserta elementos de rg		Caso promedio O(N) (N es ranges::distance(rg)), peor caso O(N2)
X(il)			X(il.begin(), il.end())
X(il, n)			X(il.begin(), il.end(), n)
X(il, n, hf)			X(il.begin(), il.end(), n, hf)
X(il, n, hf, eq)			X(il.begin(), il.end(), n, hf, eq)
X(b)			Container; copia la función de hash, el predicado y el factor de carga máximo		Caso promedio lineal en b.size(), peor caso O(N2)
a = b	X&		Container; copia la función de hash, el predicado y el factor de carga máximo		Caso promedio lineal en b.size(), peor caso O(N2)
a = il	X&	value_type es CopyInsertable en X y CopyAssignable	Asigna el rango [il.begin(), il.end()) a a. Todos los elementos existentes de a se asignan o se destruyen		Caso promedio lineal en il.size(), peor caso O(N2)
b.hash_function()	hasher			Función de hash de b	Constante
b.key_eq()	key_equal			Predicado de igualdad de clave de b	Constante
a_uniq.emplace(args)	std::pair<   iterator,   bool>	value_type es EmplaceConstructible en X a partir de args	Inserta un objeto value_typet construido con std::forward<Args>(args)...si y solo si no hay un elemento en el contenedor con clave equivalente a la clave de t	El componente bool del par devuelto es true si y solo si la inserción tuvo lugar, y el componente iterador del par apunta al elemento con la clave equivalente a la clave de t	Caso promedio O(1), peor caso O(a_uniq.size())
a_eq.emplace(args)	iterator	value_type es EmplaceConstructible en X a partir de args	Inserta un objeto value_typet construido con std::forward<Args>(args)...	Un iterador apuntando al elemento insertado	Caso promedio O(1), peor caso O(a_eq.size())
a.emplace_hint(p, args)	iterator	value_type es EmplaceConstructible en X a partir de args	a.emplace(   std::forward<Args>(args)...)	Un iterador apuntando al elemento con la clave equivalente al elemento insertado. El const_iteratorp es una sugerencia que indica donde debe comenzar la búsqueda. Las implementaciones pueden ignorar la sugerencia.	Caso promedio O(1), peor caso O(a.size())
a_uniq.insert(t)	std::pair<   iterator,   bool>	Si t es un r-valor no constante, value_type es MoveInsertable en X; en otro caso, value_type es CopyInsertable en X	Inserta t si y solo si no hay un elemento en el contenedor con clave equivalente a la clave de t	El componente bool del par devuelto indica si la inserción tuvo lugar, y el componente iterator apunta al elemento con la clave equivalente de la clave de t	Caso promedio O(1), peor caso O(a_uniq.size())
a_eq.insert(t)	iterator	Si t es un r-valor no constante, value_type es MoveInsertable en X; en otro caso, value_type es CopyInsertable en X	Inserta t	Un iterador apuntado al elemento insertado	Caso promedio O(1), peor caso O(a_eq.size())
a.insert(p, t)	iterator	Si t es un r-valor no constante, value_type es MoveInsertable en X; en otro caso, value_type es CopyInsertable en X	a.insert(t). El iterador p es una sugerencia de donde debe comenzar la búsqueda. Se permite que la implementación ignore esta sugerencia.	Un iterador apuntando al elemento con clave equivalente a la de t	Caso promedio O(1), peor caso O(a.size())
a.insert(i, j)	void	value_type es EmplaceConstructible en X a partir de *i. Ni i ni j son iteradores en a	a.insert(t) para cada elemento en [i, j)		Caso promedio O(N), donde N es std::distance(i, j), peor caso O(N·(a.size()+1))
a.insert_range(rg) (desde C++23)	void	value_type es EmplaceConstructible en X a partir de *ranges::begin(rg). rg y a no se solapan	a.insert(t) para cada elemento t en rg		Caso promedio O(N), donde N es ranges::distance(rg), pero caso O(N·(a.size()+1))
a.insert(il)			a.insert(il.begin(), il.end())
a_uniq.insert(nh) (desde C++17)	insert_return_type	nh está vacío o a_uniq.get_allocator() == nh.get_allocator() es true	Si nh está vacío, no tiene efecto. En otro caso, inserta el elemento de nh si y solo si no hay un elemento en el contenedor con una clave equivalente a nh.key(). Ensures: Si nh está vacío, inserted es false, position es end(), y node está vacío. En otro caso, si la inserción tiene lugar, inserted es true, position apunta al elemento insertado, y node está vacío; si la inserción falla, inserted es false, node tiene el valor previo de nh, y position apunta a un elemento con una clave equivalente a nh.key()		Caso promedio O(1), peor caso O(a_uniq.size())
a_eq.insert(nh) (desde C++17)	iterator	nh está vacío o a_eq.get_allocator() == nh.get_allocator() es true	Si nh está vacío, no tiene efecto y devuelve a_eq.end(). En otro caso, inserta el elemento de nh y devuelve un iterador apuntando al nuevo elemento insertado. Asegura: nh está vacío.		Caso promedio O(1), peor caso O(a_eq.size())
a.insert(q, nh) (desde C++17)	iterator	nh está vacío o a.get_allocator() == nh.get_allocator() es true	Si nh está vacío, no tiene efecto y devuelve a.end(). En otro caso, inserta el elemento de nh si y solo si no hay un elemento con la clave equivalente a nh.key() en contenedores con claves únicas; siempre inserta el elemento de nh en contenedores con claves equivalentes. El iterador q es una sugerencia de donde debe comenzar la búsqueda. Se permite que las implementaciones ignoren esta sugerencia. Asegura: nh está vacío si la inserción es correcta, sin cambio si la inserción falla.	Un iterador apuntado al elemento con clave equivalente a nh.key()	Caso promedio O(1), peor caso O(a.size())
a.extract(k) (desde C++17)	node_type		Elimina un elemento en el contenedor con la clave equivalente a k	Un node_type que posee el elemento si se encuentra, en otro caso, un node_type vacío	Caso promedio O(1), peor caso O(a.size())
a_tran.extract(kx) (desde C++23)	node_type		Elimina un elemento en el contenedor con la clave equivalente a kx	Un node_type que posee el elemento si se encuentra, en otro caso, un node_type vacío	Caso promedio O(1), peor caso O(a_tran.size())
a.extract(q) (desde C++17)	node_type		Elimina el elemento apuntado por q	Un node_type que posee este elemento	Caso promedio O(1), peor caso O(a.size())
a.merge(a2) (desde C++17)	void	a.get_allocator() == a2.get_allocator()	Intenta extraer cada elemento en a2 e insertarlo en a usando la función de hash y el predicado de igualdad de clave de a. En contenedores con clave única, si hay un elemento en a con la clave equivalente a la clave de un elemento de a2, entonces este elemento no se extrae de a2. Asegura: los punteros y referencias a los elementos transferidos de a2 hacen referencia a esos mismos elementos pero como miembros de a. Los iteradores que hacen referencia a los elementos transferidos y todos los iteradores que hacen referencia a a se invalidan, pero los iteradores a los elementos que quedan en a2 siguen siendo válidos		Caso promedio O(N), donde N es a2.size(), peor caso O(N·(a.size()+1))
a.erase(k)	size_type		Elimina todos los elementos con la clave equivalente a k	El número de elementos eliminados	Caso promedio O(a.count(k)), peor caso O(a.size())
a_tran.erase(kx) (desde C++23)	size_type		Elimina todos los elementos con la clave equivalente a kx	El número de elementos eliminados	Caso promedio O(a_tran.count(kx)), peor caso O(a_tran.size())
a.erase(q)	iterator		Elimina el elemento apuntado por q	El iterador que sigue inmediatamente a q antes del borrado	Caso promedio O(1), peor caso O(a.size())
a.erase(r) (desde C++17)	iterator		Elimina el elemento apuntado por r	El iterador que sigue inmediatamente a r antes del borrado	Caso promedio O(1), peor caso O(a.size())
a.erase(q1, q2)	iterator		Elimina todos los elementos en el rango [q1, q2)	El iterador que sigue inmediatamente a los elementos eliminados antes del borrado	Caso promedio lineal en std::distance(q1, q2), peor caso O(a.size())
a.clear()	void		Elimina todos los elementos del contenedor. Asegura: a.empty() es true		Lineal en a.size()
b.find(k)	iterator; const_iterator para b constante			Un iterador apuntado a un elemento con clave equivalente a k, o b.end() si no existe dicho elemento	Caso promedio O(1), peor caso O(b.size())
a_tran.find(ke) (desde C++17)?	iterator; const_iterator para a_tran constante			Un iterador apuntando a un elemento con clave equivalente a ke, o a_tran.end() si no existe dicho elemento	Caso promedio O(1), peor caso O(a_tran.size())
b.count(k)	size_type			El número de elementos con clave equivalente a k	Caso promedio O(b.count(k)), peor caso O(b.size())
a_tran.count(ke) (desde C++17)?	size_type			El número de elementos con clave equivalente a ke	Caso promedio O(a_tran.count(ke)), peor caso O(a_tran.size())
b.contains(k) (desde C++20)?			b.find(k)!= b.end()
a_tran.contains(ke) (desde C++20)?			a_tran.find(ke)!= a_tran.end()
b.equal_range(k)	std::pair<   iterator,   iterator>; std::pair<   const_iterator,   const_iterator> para b constante			Un rango que contiene todos los elementos con clave equivalente a k. Devuelve std::make_pair(   b.end(), b.end()) si no existen dichos elementos	Caso promedio O(b.count(k)), peor caso O(b.size())
a_tran.equal_range(ke) (desde C++20)?	std::pair<   iterator,   iterator>; std::pair<   const_iterator,   const_iterator> para a_tran constante			Un rango que contiene todos los elementos con claves equivalentes a ke. Devuelve std::make_pair(   a_tran.end(),   a_tran.end()) si dichos elementos no existen	Caso promedio O(a_tran.count(ke)), peor caso O(a_tran.size())
b.bucket_count()	size_type			El número de agrupaciones que contiene b	Constante
b.max_bucket_count()	size_type			Un límite superior para el número de agrupaciones que b puede contener	Constante
b.bucket(k)	size_type	b.bucket_count()>0		El índice de la agrupación en el que se encontrarían los elementos con claves equivalentes a k, si existiera dicho elemento. El valor devuelto está en el rango [​0​, b.bucket_count())	Constante
a_tran.bucket(ke)	size_type	a_tran. bucket_count()>0		El índice de la agrupación en el que se encontraría los elementos con claves equivalentes a ke, si existiera dicho elemento. El valor devuelto debe estar en el rango [​0​, a_tran.bucket_count())	Constante
b.bucket_size(n)	size_type	n está en el rango [​0​, b.bucket_count())		El número de elementos en la agrupación enesima	O(b.bucket_size(n))
b.begin(n)	local_iterator; const_local_iterator para b constante	n está en el rango [​0​, b.bucket_count())		Un iterador referenciando al primer elemento en la agrupación. Si la agrupación está vacía, entonces b.begin(n)== b.end(n)	Constante
b.end(n)	local_iterator; const_local_iterator para b constante	n está en el rango [​0​, b.bucket_count())		Un iterador que es el valor más allá del final de la agrupación	Constante
b.cbegin(n)	const_local_iterator	n está en el rango [​0​, b.bucket_count())		Un iterador que referencia al primer elemento en la agrupación. Si la agrupación está vacía, entonces b.cbegin(n)== b.cend(n)	Constante
b.cend(n)	const_local_iterator	n está en el rango [​0​, b.bucket_count())		Un iterador que es el valor más allá del final de la agrupación	Constante
b.load_factor()	float			El número promedio de elementos por agrupación	Constante
b.max_load_factor()	float			Un número positivo que el contenedor intenta mantener con un factor de carga menor o igual a este. El contenedor aumenta automáticamente la cantidad de agrupaciones como sea necesario para mantener el factor de carga por debajo de este número.	Constante
a.max_load_factor(z)	void	z es positivo. Puede cambiar el factor de carga máxima del contenedor, usando z como guía			Constante
a.rehash(n)	void		Asegura: a.bucket_count()>=   a.size()/ a.max_load_factor() y a.bucket_count()>= n		Caso promedio lineal en a.size(), peor caso O(N2)
a.reserve(n)			a.rehash(std::ceil(   n / a.max_load_factor()))

Contenedores asociativos no ordenados en la biblioteca estándar

unordered_set (desde C++11)	Colección de claves únicas, dispersas (hashed) por claves. (plantilla de clase)
unordered_multiset (desde C++11)	Colección de claves, dispersos (hashed) por claves. (plantilla de clase)
unordered_map (desde C++11)	Colección de pares de clave-valor, dispersos (hashed) por claves, donde las claves son únicas. (plantilla de clase)
unordered_multimap (desde C++11)	Colección de pares de clave-valor, dispersos (hashed) por clave. (plantilla de clase)

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 2156	C++11	el factor de carga después del rehashing solo podía ser estrictamente inferior al factor de carga máximo	se permite que sea igual