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)
Défini dans l'en-tête <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 /* voir ci-dessous */ :: size_type = /* voir ci-dessous */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )
- > unordered_map < /*iter-key-t*/ < InputIt > , /*iter-val-t*/ < InputIt > ,

Hash, Pred, Alloc > ;
(1) (depuis 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 /* voir ci-dessous */ :: size_type = /* voir ci-dessous */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )

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

unordered_map ( InputIt, InputIt, typename /* voir ci-dessous */ :: 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) (depuis 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) (depuis C++17)
template < class InputIt, class Hash, class Alloc >

unordered_map ( InputIt, InputIt, typename /* voir ci-dessous */ :: size_type , Hash,
Alloc )
- > unordered_map < /*iter-key-t*/ < InputIt > , /*iter-val-t*/ < InputIt > , Hash,

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

unordered_map ( std:: initializer_list < std:: pair < Key, T >> ,
typename /* voir ci-dessous */ :: size_type , Alloc )

- > unordered_map < Key, T, std:: hash < Key > , std:: equal_to < Key > , Alloc > ;
(6) (depuis 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) (depuis C++17)
template < class Key, class T, class Hash, class Alloc >

unordered_map ( std:: initializer_list < std:: pair < Key, T >> ,
typename /* voir ci-dessous */ :: size_type , Hash, Alloc )

- > unordered_map < Key, T, Hash, std:: equal_to < Key > , Alloc > ;
(8) (depuis 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 /* voir ci-dessous */ :: size_type = /* voir ci-dessous */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )
- > unordered_map < /*range-key-t*/ < R > , /*range-mapped-t*/ < R > ,

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

unordered_map ( std:: from_range_t , R && ,
typename /* voir ci-dessous */ :: 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) (depuis 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) (depuis C++23)
template < ranges:: input_range R, class Hash, class Alloc >

unordered_map ( std:: from_range_t , R && , typename /* voir ci-dessous */ :: size_type ,
Hash, Alloc )
- > unordered_map < /*range-key-t*/ < R > , /*range-mapped-t*/ < R > , Hash,

std:: equal_to < /*range-key-t*/ < R >> , Alloc > ;
(12) (depuis C++23)
Alias de types d'assistance à exposition uniquement
template < class InputIt >

using /*iter-val-t*/ =

typename std:: iterator_traits < InputIt > :: value_type ;
( exposition uniquement* )
template < class InputIt >

using /*iter-key-t*/ =

std:: remove_const_t < std:: tuple_element_t < 0 , /*iter-val-t*/ < InputIt >>> ;
( exposition uniquement* )
template < class InputIt >

using /*iter-mapped-t*/ =

std:: tuple_element_t < 1 , /*iter-val-t*/ < InputIt >> ;
( exposition uniquement* )
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 >>> ;
( exposition uniquement* )
template < ranges:: input_range Range >

using /*range-key-t*/ =

std:: remove_const_t < typename ranges:: range_value_t < Range > :: first_type > ;
(depuis C++23)
( exposition uniquement* )
template < ranges:: input_range Range >

using /*type-mappé-de-plage*/ =

typename ranges:: range_value_t < Range > :: second_type ;
(depuis C++23)
( exposition uniquement* )
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 > ;
(depuis C++23)
( exposition uniquement* )
1-8) Ces guides de déduction sont fournis pour unordered_map afin de permettre la déduction à partir d'une plage d'itérateurs (surcharges (1,3-5) ) et std::initializer_list (surcharges (2,6-8) ).
9-12) Ces guides de déduction sont fournis pour unordered_map afin de permettre la déduction à partir d'un tag std::from_range_t et d'un input_range .

Ces surcharges participent à la résolution de surcharge seulement si InputIt satisfait LegacyInputIterator , Alloc satisfait Allocator , ni Hash ni Pred ne satisfont Allocator , et Hash n'est pas un type intégral.

Note : la mesure dans laquelle la bibliothèque détermine qu'un type ne satisfait pas LegacyInputIterator n'est pas spécifiée, sauf qu'au minimum les types entiers ne sont pas qualifiés comme itérateurs d'entrée. De même, la mesure dans laquelle elle détermine qu'un type ne satisfait pas Allocator n'est pas spécifiée, sauf qu'au minimum le type membre Alloc::value_type doit exister et l'expression std:: declval < Alloc & > ( ) . allocate ( std:: size_t { } ) doit être bien formée lorsqu'elle est traitée comme un opérande non évalué.

Le paramètre de type size_type dans ces guides fait référence au type membre size_type du type déduit par le guide de déduction.

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_containers_ranges 202202L (C++23) Construction et insertion compatibles avec les gammes ; surcharges ( 9-12 )

Exemple

Exécuter ce code 
#include <unordered_map>
int main()
{
    // std::unordered_map m1 = {{"foo", 1}, {"bar", 2}};
        // Erreur : la liste d'initialisation entre accolades n'a pas de type : impossible
        // de déduire pair<Key, T> à partir de {"foo", 1} ou {"bar", 2}
    std::unordered_map m1 = {std::pair{"foo", 2}, {"bar", 3}}; // guide #2
    std::unordered_map m2(m1.begin(), m1.end()); // guide #1
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 3025 C++17 les guides d'initialisation ( 2 ) et ( 6-8 ) utilisent std:: pair < const Key, T > utilisent std:: pair < Key, T >