Namespaces
Variants

deduction guides for std::unordered_map

From cppreference.net

C++
Containers library
std::unordered_map
Member types
Member functions
Non-member functions
Deduction guides (C++17)
Definido en el encabezado <unordered_map>
template < class InputIt,

class Hash = std:: hash < /*iter-key-t*/ < InputIt >> ,
class Pred = std:: equal_to < /*iter-key-t*/ < InputIt >> ,
class Alloc = std:: allocator < /*iter-to-alloc-t*/ < InputIt >> >
unordered_map ( InputIt, InputIt,
typename /* ver abajo */ :: size_type = /* ver abajo */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )
- > unordered_map < /*iter-key-t*/ < InputIt > , /*iter-val-t*/ < InputIt > ,

Hash, Pred, Alloc > ;
(1) (desde C++17)
template < class Key, class T, class Hash = std:: hash < Key > ,

class Pred = std:: equal_to < Key > ,
class Alloc = std:: allocator < std:: pair < const Key, T >> >
unordered_map ( std:: initializer_list < std:: pair < Key, T >> ,
typename /* ver más abajo */ :: size_type = /* ver más abajo */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )

- > unordered_map < Key, T, Hash, Pred, Alloc > ;
(2) (desde C++17)
template < class InputIt, class Alloc >

unordered_map ( InputIt, InputIt, typename /* ver abajo */ :: size_type , Alloc )
- > unordered_map < /*iter-key-t*/ < InputIt > , /*iter-val-t*/ < InputIt > ,
std:: hash < /*iter-key-t*/ < InputIt >> ,

std:: equal_to < /*iter-key-t*/ < InputIt >> , Alloc > ;
(3) (desde C++17)
template < class InputIt, class Alloc >

unordered_map ( InputIt, InputIt, Alloc )
- > unordered_map < /*iter-key-t*/ < InputIt > , /*iter-val-t*/ < InputIt > ,
std:: hash < /*iter-key-t*/ < InputIt >> ,

std:: equal_to < /*iter-key-t*/ < InputIt >> , Alloc > ;
(4) (desde C++17)
template < class InputIt, class Hash, class Alloc >

unordered_map ( InputIt, InputIt, typename /* ver abajo */ :: size_type , Hash,
Alloc )
- > unordered_map < /*iter-key-t*/ < InputIt > , /*iter-val-t*/ < InputIt > , Hash,

std:: equal_to < /*iter-key-t*/ < InputIt >> , Alloc > ;
(5) (desde C++17)
template < class Key, class T, typename Alloc >

unordered_map ( std:: initializer_list < std:: pair < Key, T >> ,
typename /* ver más abajo */ :: size_type , Alloc )

- > unordered_map < Key, T, std:: hash < Key > , std:: equal_to < Key > , Alloc > ;
(6) (desde C++17)
template < class Key, class T, typename Alloc >

unordered_map ( std:: initializer_list < std:: pair < Key, T >> , Alloc )

- > unordered_map < Key, T, std:: hash < Key > , std:: equal_to < Key > , Alloc > ;
(7) (desde C++17)
template < class Key, class T, class Hash, class Alloc >

unordered_map ( std:: initializer_list < std:: pair < Key, T >> ,
typename /* ver abajo */ :: size_type , Hash, Alloc )

- > unordered_map < Key, T, Hash, std:: equal_to < Key > , Alloc > ;
(8) (desde C++17)
template < ranges:: input_range R,

class Hash = std:: hash < /*range-key-t*/ < R >> ,
class Pred = std:: equal_to < /*range-key-t*/ < R >> ,
class Alloc = std:: allocator < /*range-to-alloc-t*/ < R >> >
unordered_map ( std:: from_range_t , R && ,
typename /* ver abajo */ :: size_type = /* ver abajo */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )
- > unordered_map < /*range-key-t*/ < R > , /*range-mapped-t*/ < R > ,

Hash, Pred, Alloc > ;
(9) (desde C++23)
template < ranges:: input_range R, class Alloc >

unordered_map ( std:: from_range_t , R && ,
typename /* ver abajo */ :: size_type , Alloc )
- > unordered_map < /*range-key-t*/ < R > , /*range-mapped-t*/ < R > ,
std:: hash < /*range-key-t*/ < R >> ,

std:: equal_to < /*range-key-t*/ < R >> , Alloc > ;
(10) (desde C++23)
template < ranges:: input_range R, class Alloc >

unordered_map ( std:: from_range_t , R && , Alloc )
- > unordered_map < /*range-key-t*/ < R > , /*range-mapped-t*/ < R > ,
std:: hash < /*range-key-t*/ < R >> ,

std:: equal_to < /*range-key-t*/ < R >> , Alloc > ;
(11) (desde C++23)
template < ranges:: input_range R, class Hash, class Alloc >

unordered_map ( std:: from_range_t , R && , typename /* ver más abajo */ :: size_type ,
Hash, Alloc )
- > unordered_map < /*range-key-t*/ < R > , /*range-mapped-t*/ < R > , Hash,

std:: equal_to < /*range-key-t*/ < R >> , Alloc > ;
(12) (desde C++23)
Alias de tipos auxiliares solo para exposición
template < class InputIt >

using /*iter-val-t*/ =

typename std:: iterator_traits < InputIt > :: value_type ;
( solo para exposición* )
template < class InputIt >

using /*iter-key-t*/ =

std:: remove_const_t < std:: tuple_element_t < 0 , /*iter-val-t*/ < InputIt >>> ;
( solo para exposición* )
template < class InputIt >

using /*iter-mapped-t*/ =

std:: tuple_element_t < 1 , /*iter-val-t*/ < InputIt >> ;
( solo para exposición* )
template < class InputIt >

using /*iter-to-alloc-t*/ =
std:: pair < std:: add_const_t < tuple_element_t < 0 , /*iter-val-t*/ < InputIt >>> ,

std:: tuple_element_t < 1 , /*iter-val-t*/ < InputIt >>> ;
( solo para exposición* )
template < ranges:: input_range Range >

using /*range-key-t*/ =

std:: remove_const_t < typename ranges:: range_value_t < Range > :: first_type > ;
(desde C++23)
( solo para exposición* )
template < ranges:: input_range Range >

using /*range-mapped-t*/ =

typename ranges:: range_value_t < Range > :: second_type ;
(desde C++23)
( solo para exposición* )
template < ranges:: input_range Range >

using /*range-to-alloc-t*/ =
std:: pair < std:: add_const_t < typename ranges:: range_value_t < Range > :: first_type > ,

typename ranges:: range_value_t < Range > :: second_type > ;
(desde C++23)
( solo para exposición* )
1-8) Estas guías de deducción se proporcionan para unordered_map para permitir la deducción desde un rango de iteradores (sobrecargas (1,3-5) ) y std::initializer_list (sobrecargas (2,6-8) ).
9-12) Estas guías de deducción se proporcionan para unordered_map para permitir la deducción a partir de una etiqueta std::from_range_t y un input_range .

Estas sobrecargas participan en la resolución de sobrecarga solo si InputIt satisface LegacyInputIterator , Alloc satisface Allocator , ni Hash ni Pred satisfacen Allocator , y Hash no es un tipo integral.

Nota: el grado en que la biblioteca determina que un tipo no satisface LegacyInputIterator no está especificado, excepto que como mínimo los tipos integrales no califican como iteradores de entrada. Del mismo modo, el grado en que determina que un tipo no satisface Allocator no está especificado, excepto que como mínimo el tipo miembro Alloc::value_type debe existir y la expresión std:: declval < Alloc & > ( ) . allocate ( std:: size_t { } ) debe estar bien formada cuando se trata como un operando no evaluado.

El size_type tipo de parámetro en estas guías se refiere al size_type tipo miembro del tipo deducido por la guía de deducción.

Notas

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

Ejemplo

Ejecutar este código 
#include <unordered_map>
int main()
{
    // std::unordered_map m1 = {{"foo", 1}, {"bar", 2}};
        // Error: la lista de inicialización entre llaves no tiene tipo: no se puede
        // deducir pair<Key, T> de {"foo", 1} o {"bar", 2}
    std::unordered_map m1 = {std::pair{"foo", 2}, {"bar", 3}}; // guía #2
    std::unordered_map m2(m1.begin(), m1.end()); // guía #1
}

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 3025 C++17 las guías de lista de inicialización ( 2 ) y ( 6-8 ) toman std:: pair < const Key, T > usan std:: pair < Key, T >