Namespaces
Variants

deduction guides for std::unordered_multimap

From cppreference.net

C++
Containers library
std::unordered_multimap
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_multimap ( InputIt, InputIt,
typename /* siehe unten */ :: size_type = /* siehe unten */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )
- > unordered_multimap < /*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_multimap ( std:: initializer_list < std:: pair < Key, T >> ,
typename /* siehe unten */ :: size_type = /* siehe unten */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )

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

unordered_multimap ( InputIt, InputIt, typename /* siehe unten */ :: size_type , Alloc )
- > unordered_multimap < /*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_multimap ( InputIt, InputIt, Alloc )
- > unordered_multimap < /*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_multimap ( InputIt, InputIt, typename /* siehe unten */ :: size_type , Hash,
Alloc )
- > unordered_multimap < /*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_multimap ( std:: initializer_list < std:: pair < Key, T >> ,
typename /* siehe unten */ :: size_type , Alloc )

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

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

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

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

- > unordered_multimap < 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_multimap ( std:: from_range_t , R && ,
typename /* siehe unten */ :: size_type = /* siehe unten */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )
- > unordered_multimap < /*range-key-t*/ < R > , /*range-mapped-t*/ < R > ,

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

unordered_multimap ( std:: from_range_t , R && ,
typename /* siehe unten */ :: size_type , Alloc )
- > unordered_multimap < /*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_multimap ( std:: from_range_t , R && , Alloc )
- > unordered_multimap < /*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_multimap ( std:: from_range_t , R && , typename /* siehe unten */ :: size_type ,
Hash, Alloc )
- > unordered_multimap < /*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 Darstellung* )
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 Deduction Guides werden für unordered_multimap bereitgestellt, um die Ableitung aus einem Iteratorbereich (Overloads (1,3-5) ) und std::initializer_list (Overloads (2,6-8) ) zu ermöglichen.
9-12) Diese Deduktionsführer werden für unordered_multimap 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 LegacyInputIterator erfüllt, Alloc die Anforderungen Allocator erfüllt, weder Hash noch Pred die Anforderungen 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_multimap m1 = {{"foo", 1}, {"bar", 2}};
        // Fehler: Initialisierungsliste hat keinen Typ: kann
        // pair<Key, T> nicht von {"foo", 1} oder {"bar", 2} ableiten
    std::unordered_multimap m1 = {std::pair{"foo", 2}, {"bar", 3}}; // Anleitung #2
    std::unordered_multimap m2(m1.begin(), m1.end()); // Anleitung #1
}
**Übersetzungserläuterungen:** - "Run this code" → "Diesen Code ausführen" - "Error: braced-init-list has no type: cannot deduce pair from..." → "Fehler: Initialisierungsliste hat keinen Typ: kann pair nicht von... ableiten" - "guide" → "Anleitung" (im Kontext von Template-Argument-Deduktion) - Alle HTML-Tags, Attribute und Code-Blöcke wurden unverändert beibehalten - C++-spezifische Begriffe wie `unordered_multimap`, `pair`, `begin`, `end` wurden nicht übersetzt

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-Deduktionsregeln ( 2 ) und ( 6-8 ) verwenden std:: pair < const Key, T > verwenden std:: pair < Key, T >