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)
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt unverändert, wie angefordert.)
Definiert in Header <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 /* siehe unten */ :: size_type = /* siehe unten */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )
- > unordered_map < /*iter-key-t*/ < InputIt > , /*iter-val-t*/ < InputIt > ,

Hash, Pred, Alloc > ;
(1) (seit 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 /* siehe unten */ :: size_type = /* siehe unten */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )

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

unordered_map ( InputIt, InputIt, typename /* siehe unten */ :: 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) (seit 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) (seit C++17)
template < class InputIt, class Hash, class Alloc >

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

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

unordered_map ( std:: initializer_list < std:: pair < Key, T >> ,
typename /* siehe unten */ :: size_type , Alloc )

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

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

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

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

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

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

std:: equal_to < /*range-key-t*/ < R >> , Alloc > ;
(12) (seit C++23)
Nur zur Darstellung dienende Hilfstyp-Aliase
template < class InputIt >

using /*iter-val-t*/ =

typename std:: iterator_traits < InputIt > :: value_type ;
( nur zur Veranschaulichung* )
template < class InputIt >

using /*iter-key-t*/ =

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

using /*iter-mapped-t*/ =

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

using /*range-key-t*/ =

std:: remove_const_t < typename ranges:: range_value_t < Range > :: first_type > ;
(seit C++23)
( nur zur Darstellung* )
template < ranges:: input_range Range >

using /*range-mapped-t*/ =

typename ranges:: range_value_t < Range > :: second_type ;
(seit C++23)
( nur zur Darstellung* )
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 > ;
(seit C++23)
( nur zur Darstellung* )
1-8) Diese Deduktionsleitfäden werden für unordered_map bereitgestellt, um die Deduktion aus einem Iteratorbereich (Überladungen (1,3-5) ) und std::initializer_list (Überladungen (2,6-8) ) zu ermöglichen.
9-12) Diese Deduktionsführer werden für unordered_map bereitgestellt, um die Ableitung von einem std::from_range_t -Tag und einem input_range zu ermöglichen.

Diese Überladungen nehmen nur dann an der Überladungsauflösung teil, wenn InputIt die Anforderungen eines LegacyInputIterator erfüllt, Alloc die Anforderungen eines Allocator erfüllt, weder Hash noch Pred die Anforderungen eines Allocator erfüllen und Hash kein integraler Typ ist.

Hinweis: Das Ausmaß, in dem die Bibliothek feststellt, dass ein Typ nicht die Anforderungen eines LegacyInputIterator erfüllt, ist nicht spezifiziert, außer dass mindestens integrale Typen nicht als Input-Iteratoren qualifizieren. Ebenso ist das Ausmaß, in dem sie feststellt, dass ein Typ nicht die Anforderungen eines Allocator erfüllt, nicht spezifiziert, außer dass mindestens der Member-Typ Alloc::value_type existieren muss und der Ausdruck std:: declval < Alloc & > ( ) . allocate ( std:: size_t { } ) wohlgeformt sein muss, wenn er als nicht ausgewerteter Operand behandelt wird.

Der size_type -Parametertyp in diesen Leitfäden bezieht sich auf den size_type -Mitgliedstyp des durch den Deduktionsleitfaden abgeleiteten Typs.

Hinweise

Feature-Test Makro Wert Std Feature
__cpp_lib_containers_ranges 202202L (C++23) Ranges-basierte Konstruktion und Einfügung; Überladungen ( 9-12 )

Beispiel

Diesen Code ausführen 
#include <unordered_map>
int main()
{
    // std::unordered_map m1 = {{"foo", 1}, {"bar", 2}};
        // Fehler: Initialisierungsliste hat keinen Typ: kann
        // pair<Key, T> nicht von {"foo", 1} oder {"bar", 2} ableiten
    std::unordered_map m1 = {std::pair{"foo", 2}, {"bar", 3}}; // Guide #2
    std::unordered_map m2(m1.begin(), m1.end()); // Guide #1
}

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 3025 C++17 Initializer-List-Deduktionsleitlinien ( 2 ) und ( 6-8 ) verwenden std:: pair < const Key, T > verwenden std:: pair < Key, T >