Namespaces
Variants

std::unordered_map<Key,T,Hash,KeyEqual,Allocator>:: unordered_map

From cppreference.net

C++
Containers library
std::unordered_map
Member types
Member functions
Non-member functions
Deduction guides (C++17)
**Notas sobre la traducción:** - Se preservaron todos los tags HTML y atributos sin cambios - El código C++ dentro de ` ` no fue traducido - Solo se tradujo el texto "since C++11" a "desde C++11" - Los términos específicos de C++ (explicit, unordered_map, size_type, const, Hash, key_equal, Allocator) se mantuvieron en inglés - La estructura y formato HTML se conservaron intactos
(1)
unordered_map ( )
: unordered_map ( size_type ( /* unspecified */ ) ) { }
(desde C++11)
(hasta C++20)
unordered_map ( ) ;
(desde C++20)
explicit unordered_map ( size_type bucket_count,

const Hash & hash = Hash ( ) ,
const key_equal & equal = key_equal ( ) ,

const Allocator & alloc = Allocator ( ) ) ;
(2) (desde C++11)
unordered_map ( size_type bucket_count,

const Allocator & alloc )

: unordered_map ( bucket_count, Hash ( ) , key_equal ( ) , alloc ) { }
(3) (desde C++14)
unordered_map ( size_type bucket_count,

const Hash & hash,
const Allocator & alloc )

: unordered_map ( bucket_count, hash, key_equal ( ) , alloc ) { }
(4) (desde C++14)
explicit unordered_map ( const Allocator & alloc ) ;
(5) (desde C++11)
template < class InputIt >

unordered_map ( InputIt first, InputIt last,
size_type bucket_count = /* no especificado */ ,
const Hash & hash = Hash ( ) ,
const key_equal & equal = key_equal ( ) ,

const Allocator & alloc = Allocator ( ) ) ;
(6) (desde C++11)
template < class InputIt >

unordered_map ( InputIt first, InputIt last,
size_type bucket_count,
const Allocator & alloc )
: unordered_map ( first, last,

bucket_count, Hash ( ) , key_equal ( ) , alloc ) { }
(7) (desde C++14)
template < class InputIt >

unordered_map ( InputIt first, InputIt last,
size_type bucket_count,
const Hash & hash,
const Allocator & alloc )
: unordered_map ( first, last,

bucket_count, hash, key_equal ( ) , alloc ) { }
(8) (desde C++14)
unordered_map ( const unordered_map & other ) ;
(9) (desde C++11)
unordered_map ( const unordered_map & other, const Allocator & alloc ) ;
(10) (desde C++11)
unordered_map ( unordered_map && other ) ;
(11) (desde C++11)
unordered_map ( unordered_map && other, const Allocator & alloc ) ;
(12) (desde C++11)
unordered_map ( std:: initializer_list < value_type > init,

size_type bucket_count = /* sin especificar */ ,
const Hash & hash = Hash ( ) ,
const key_equal & equal = key_equal ( ) ,

const Allocator & alloc = Allocator ( ) ) ;
(13) (desde C++11)
unordered_map ( std:: initializer_list < value_type > init,

size_type bucket_count,
const Allocator & alloc )
: unordered_map ( init, bucket_count,

Hash ( ) , key_equal ( ) , alloc ) { }
(14) (desde C++14)
unordered_map ( std:: initializer_list < value_type > init,

size_type bucket_count,
const Hash & hash,
const Allocator & alloc )
: unordered_map ( init, bucket_count,

hash, key_equal ( ) , alloc ) { }
(15) (desde C++14)
template < container-compatible-range < value_type > R >

unordered_map ( std:: from_range_t , R && rg,
size_type bucket_count = /* ver descripción */ ,
const Hash & hash = Hash ( ) ,
const key_equal & equal = key_equal ( ) ,

const Allocator & alloc = Allocator ( ) ) ;
(16) (desde C++23)
template < container-compatible-range < value_type > R >

unordered_map ( std:: from_range_t , R && rg,
size_type bucket_count,
const Allocator & alloc )
: unordered_map ( std:: from_range , std:: forward < R > ( rg ) ,

bucket_count, Hash ( ) , key_equal ( ) , alloc ) { }
(17) (desde C++23)
template < container-compatible-range < value_type > R >

unordered_map ( std:: from_range_t , R && rg,
size_type bucket_count,
const Hash & hash,
const Alloc & alloc )
: unordered_map ( std:: from_range , std:: forward < R > ( rg ) ,

bucket_count, hash, key_equal ( ) , alloc ) { }
(18) (desde C++23)

Construye un nuevo contenedor a partir de diversas fuentes de datos. Opcionalmente utiliza el bucket_count proporcionado por el usuario como número mínimo de buckets a crear, hash como función de hash, equal como función para comparar claves y alloc como asignador de memoria.

1-5) Construye un contenedor vacío. Establece max_load_factor() a 1.0 . Para el constructor por defecto, el número de cubetas no está especificado.
6-8) Construye el contenedor con los contenidos del rango [ first , last ) . Establece max_load_factor() a 1.0 . Si múltiples elementos en el rango tienen claves que comparan equivalentes, no está especificado qué elemento se inserta (pendiente de LWG2844 ).
9,10) Constructor de copia. Construye el contenedor con la copia de los contenidos de other , copia el factor de carga, el predicado y la función hash también. Si alloc no se proporciona, el asignador se obtiene llamando a std:: allocator_traits < allocator_type > :: select_on_container_copy_construction ( other. get_allocator ( ) ) .

El parámetro de plantilla Allocator solo se deduce del primer argumento cuando se utiliza en deducción de argumentos de plantilla de clase .

(desde C++23)
11,12) Constructor de movimiento . Construye el contenedor con los contenidos de other usando semántica de movimiento. Si alloc no es proporcionado, el asignador se obtiene mediante construcción por movimiento del asignador perteneciente a other .

El parámetro de plantilla Allocator solo se deduce del primer argumento cuando se usa en deducción de argumentos de plantilla de clase .

(desde C++23)
13-15) Constructor de lista de inicialización . Construye el contenedor con el contenido de la lista de inicialización init , igual que unordered_map ( init. begin ( ) , init. end ( ) ) .
16-18) Construye el contenedor con los contenidos de rg . Si múltiples elementos en el rango tienen claves que comparan equivalentes, no está especificado qué elemento se inserta (pendiente de LWG2844 ).

Contenidos

Parámetros

alloc - asignador a utilizar para todas las asignaciones de memoria de este contenedor
bucket_count - número mínimo de cubos a utilizar en la inicialización. Si no se especifica, se utiliza un valor predeterminado no especificado
hash - función hash a utilizar
equal - función de comparación a utilizar para todas las comparaciones de claves de este contenedor
first, last - el par de iteradores que define el rango fuente de elementos a copiar
rg - un rango compatible con contenedor , es decir, un input_range cuyos elementos son convertibles a value_type
other - otro contenedor que se utilizará como fuente para inicializar los elementos del contenedor
init - lista de inicialización para inicializar los elementos del contenedor
Requisitos de tipo
-
InputIt debe cumplir con los requisitos de LegacyInputIterator .

Complejidad

1-5) Constante.
6-8) Caso promedio lineal (es decir, O(N) , donde N es std:: distance ( first, last ) ), caso peor cuadrático, es decir, O(N 2 ) .
9,10) Lineal en tamaño de other .
11,12) Constante. Si alloc es proporcionado y alloc ! = other. get_allocator ( ) , entonces lineal.
13-15) Caso promedio O(N) ( N es std:: size ( init ) ), caso peor O(N 2 ) .
16-18) Caso promedio O(N) ( N es ranges:: distance ( rg ) ), caso peor O(N 2 ) .

Excepciones

Las llamadas a Allocator::allocate pueden lanzar excepciones.

Notas

After container move construction (overload ( 11,12 ) ), references, pointers, and iterators (other than the end iterator) to otro remain valid, but refer to elements that are now in * this . The current standard makes this guarantee via the blanket statement in [container.reqmts]/67 , and a more direct guarantee is under consideration via Problema LWG 2321 .

Aunque no es formalmente requerido hasta C++23, algunas implementaciones ya han colocado el parámetro de plantilla Allocator en contextos no deducidos en modos anteriores.

Macro de prueba de características Valor Estándar Característica
__cpp_lib_containers_ranges 202202L (C++23) Construcción e inserción consciente de rangos; sobrecargas ( 16-18 )

Ejemplo

Ejecutar este código 
#include <bitset>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
struct Key
{
    std::string first;
    std::string second;
};
struct KeyHash
{
    std::size_t operator()(const Key& k) const
    {
        return std::hash<std::string>()(k.first) ^
            (std::hash<std::string>()(k.second) << 1);
    }
};
struct KeyEqual
{
    bool operator()(const Key& lhs, const Key& rhs) const
    {
        return lhs.primero == rhs.first && lhs.second == rhs.second;
    }
};
struct Foo
{
    Foo(int val_) : val(val_) {}
    int val;
    bool operator==(const Foo &rhs) const { return val == rhs.val; }
};
template<>
struct std::hash<Foo>
{
    std::size_t operator()(const Foo &f) const
    {
        return std::hash<int>{}(f.val);
    }
};
int main()
{
    // constructor por defecto: mapa vacío
    std::unordered_map<std::string, std::string> m1;
    // constructor de lista
    std::unordered_map<int, std::string> m2 =
    {
        {1, "foo"},
        {3, "bar"},
        {2, "baz"}
    };
    // constructor de copia
    std::unordered_map<int, std::string> m3 = m2;
    // constructor de movimiento
    std::unordered_map<int, std::string> m4 = std::move(m2);
    // constructor de rango
    std::vector<std::pair<std::bitset<8>, int>> v = {{0x12, 1}, {0x01,-1}};
    std::unordered_map<std::bitset<8>, double> m5(v.begin(), v.end());
    // Opción 1 para un constructor con un tipo Key personalizado
    // Define the KeyHash and KeyEqual structs and use them in the template
    std::unordered_map<Key, std::string, KeyHash, KeyEqual> m6 =
    {
        {{"John", "Doe"}, "ejemplo"},
        {{"Mary", "Sue"}, "otro"}
    };
    // Opción 2 para un constructor con un tipo Key personalizado.
    // Define un operador const == para la clase/estructura y especializar std::hash
    // estructura en el espacio de nombres std
    std::unordered_map<Foo, std::string> m7 =
    {
        {Foo(1), "Uno"}, {2, "Dos"}, {3, "Tres"}
    };
    // Option 3: Use lambdas
    // Tenga en cuenta que el recuento inicial de cubos debe pasarse al constructor
    struct Goo { int val; };
    auto hash = [](const Goo &g){ return std::hash<int>{}(g.val); };
    auto comp = [](const Goo &l, const Goo &r){ return l.val == r.val; };
    std::unordered_map<Goo, double, decltype(hash), decltype(comp)> m8(10, hash, comp);
}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2193 C++11 el constructor por defecto ( 1 ) era explícito hecho no explícito
LWG 2230 C++11 la semántica de la sobrecarga ( 13 ) no estaba especificada especificada

Véase también

asigna valores al contenedor
(función miembro pública)