Namensräume
Varianten
Aktionen

Ableitungsregeln für std::unordered_map

Von cppreference.com

[Bearbeiten-Vorlage]
 
C++
 
Container-Bibliothek
 
std::unordered_map
Membertypen
Memberfunktionen
Nicht-Member-Funktionen
Ableitungs-Guides(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_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 Beschreibung */::size_type = /* siehe Beschreibung */,
               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 Beschreibung */::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 Beschreibung */::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)
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 Ableitungsregeln werden für unordered_map bereitgestellt, um die Ableitung aus einem Iterator-Bereich (Überladungen (1,3-5)) und std::initializer_list (Überladungen (2,6-8)) zu ermöglichen.
9-12) Diese Ableitungsregeln werden für unordered_map 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 integraler Typ ist.

Hinweis: Das Ausmaß, in dem die Bibliothek feststellt, dass ein Typ LegacyInputIterator nicht erfüllt, ist nicht spezifiziert, außer dass als Minimum ganzzahlige Typen nicht als Eingabeiteratoren qualifizieren. Ebenso ist das Ausmaß, in dem sie feststellt, dass ein Typ Allocator nicht erfüllt, nicht spezifiziert, außer dass als Minimum der Mitgliedstyp Alloc::value_type existieren muss und der Ausdruck std::declval<Alloc&>().allocate(std::size_t{}) als unevaluierter Operand wohlgeformt sein muss.

Der size_type-Parametertyp in diesen Regeln bezieht sich auf den size_type-Mitgliedstyp des von der Ableitungsregel abgeleiteten Typs.

[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_map 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_map m1 = {std::pair{"foo", 2}, {"bar", 3}}; // guide #2
    std::unordered_map 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_map/deduction_guides&oldid=135907"