Namensräume
Varianten
Aktionen

Ableitungs-Guides für std::unordered_multimap

Von cppreference.com

[Bearbeiten-Vorlage]
 
C++
 
Container-Bibliothek
 
std::unordered_multimap
Membertypen
Memberfunktionen
Nicht-Member-Funktionen
Ableitungsregeln (C++17)
 
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 Beschreibung */::size_type = /* siehe Beschreibung */,
                    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 Beschreibung */::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 Beschreibung */::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)
Hilfstypenalias für den expositions-only-Bereich
template< class InputIter >

using iter_val_t =

    typename std::iterator_traits<InputIter>::value_type;
 (nur Exposition*)
template< class InputIter >

using iter_key_t =

    std::remove_const_t< std::tuple_element_t<0, iter_val_t<InputIter>>>;
 (nur Exposition*)
template< class InputIter >

using iter_mapped_t =

    std::tuple_element_t<1, iter_val_t<InputIter>>;
 (nur Exposition*)
template< class InputIter >

using iter_to_alloc_t =
    std::pair<std::add_const_t<tuple_element_t<0, iter_val_t<InputIter>>>,

              std::tuple_element_t<1, iter_val_t<InputIter>>>;
 (nur Exposition*)
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 Exposition*)
template< ranges::input_range Range >

using range_mapped_t =

    typename ranges::range_value_t<Range>::second_type;
 (seit C++23)
(nur Exposition*)
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 Exposition*)
1-8) Diese Ableitungs-Guides werden für unordered_multimap bereitgestellt, um die Ableitung aus einem Iterator-Bereich (Überladungen (1,3-5)) und einer std::initializer_list (Überladungen (2,6-8)) zu ermöglichen.
9-12) Diese Ableitungs-Guides werden für unordered_multimap bereitgestellt, um die Ableitung aus einem std::from_range_t-Tag und einem input_range zu ermöglichen.

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

Hinweis: Das Ausmaß, in dem die Bibliothek feststellt, dass ein Typ LegacyInputIterator nicht erfüllt, ist nicht spezifiziert, mit der Ausnahme, dass ganzzahlige Typen als Eingabeiteratoren nicht qualifiziert sind. Ebenso ist das Ausmaß, in dem festgestellt wird, dass ein Typ Allocator nicht erfüllt, nicht spezifiziert, mit der Ausnahme, dass als Minimum der Mitgliedstyp Alloc::value_type existieren muss und der Ausdruck std::declval<Alloc&>().allocate(std::size_t{}) gut gebildet sein muss, wenn er als nicht ausgewerteter Operand behandelt wird.

Der Parameter-Typ size_type in diesen Guides bezieht sich auf den Mitgliedstyp size_type des Typs, der vom Ableitungs-Guide abgeleitet wird.

[bearbeiten] Anmerkungen

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

[bearbeiten] Beispiel

Führen Sie diesen Code aus
#include <unordered_map>
 
int main()
{
    // std::unordered_multimap m1 = {{"foo", 1}, {"bar", 2}};
        // Error: braced-init-list has no type cannot
        // deduce pair<Key, T> from {"foo", 1} or {"bar", 2}
 
    std::unordered_multimap m1 = {std::pair{"foo", 2}, {"bar", 3}}; // guide #2
    std::unordered_multimap m2(m1.begin(), m1.end()); // guide #1
}

[bearbeiten] 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-Führer nehmen std::pair<const Key, T> verwenden std::pair<Key, T>
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/container/unordered_multimap/deduction_guides&oldid=135909"