Namensräume
Varianten
Aktionen

deduction guides für std::multimap

Von cppreference.com
< cpp‎ | container‎ | multimap

[Bearbeiten-Vorlage]
 
C++
 
Container-Bibliothek
 
std::multimap
Memberfunktionen
Nicht-Member-Funktionen
(bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Ableitungs-Guides(C++17)
 
Definiert in Header <map>
template< class InputIt,

          class Comp = std::less<iter_key_t<InputIt>>,
          class Alloc = std::allocator<iter_to_alloc_t<InputIt>> >
multimap( InputIt, InputIt, Comp = Comp(), Alloc = Alloc() )

    -> multimap<iter_key_t<InputIt>, iter_val_t<InputIt>, Comp, Alloc>;
 (1) (seit C++17)
template< class Key,

          class T,
          class Comp = std::less<Key>,
          class Alloc = std::allocator<std::pair<const Key, T>> >
multimap( std::initializer_list<std::pair<Key, T>>, Comp = Comp(), Alloc = Alloc() )

    -> multimap<Key, T, Comp, Alloc>;
 (2) (seit C++17)
template< class InputIt, class Alloc >

multimap( InputIt, InputIt, Alloc )
    -> multimap<iter_key_t<InputIt>, iter_val_t<InputIt>,

                std::less<iter_key_t<InputIt>>, Alloc>;
 (3) (seit C++17)
template< class Key, class T, class Alloc >

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

    -> multimap<Key, T, std::less<Key>, Alloc>;
 (4) (seit C++17)
template< ranges::input_range R, class Compare = std::less<range_key_t<R>,

          class Alloc = std::allocator<range_to_alloc_t<R>> >
multimap( std::from_range_t, R&&, Compare = Compare(), Alloc = Alloc() )

    -> multimap<range_key_t<R>, range_mapped_t<R>, Compare, Alloc>;
 (5) (seit C++23)
template< ranges::input_range R, class Alloc >

multimap( std::from_range_t, R&&, Alloc )

    -> multimap<range_key_t<R>, range_mapped_t<R>, std::less<range_key_t<R>>, Alloc>;
 (6) (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-4) Diese deduction guides werden für multimap bereitgestellt, um die Ableitung aus einem Iterator-Bereich (Überladungen (1,3)) und std::initializer_list (Überladungen (2,4)) zu ermöglichen.
5,6) Diese deduction guides werden für multimap bereitgestellt, um die Ableitung aus einem Tag std::from_range_t und einem input_range zu ermöglichen.

Diese Überladungen nehmen an der Überladungsauflösung teil, nur wenn InputIt LegacyInputIterator erfüllt, Alloc Allocator erfüllt und Comp Allocator nicht erfüllt.

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 qualifiziert sind. 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{}) gut gebildet sein muss, wenn er als nicht ausgewerteter Operand behandelt wird.

[edit] Anmerkungen

Feature-Test-Makro Wert Std Feature
__cpp_lib_containers_ranges 202202L (C++23) Bereichsbezogene Konstruktion und Einfügung; Überladung (5,6)

[edit] Beispiel

Führen Sie diesen Code aus
#include <map>
 
int main()
{
    // std::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::multimap m1 = {std::pair{"foo", 2}, {"bar", 3}}; // guide #2
    std::multimap m2(m1.begin(), m1.end()); // guide #1
}

[edit] 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/multimap/deduction_guides&oldid=135729"