Namensräume
Varianten
Aktionen

Deduktionshilfen für std::map

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

[Bearbeiten-Vorlage]
 
C++
 
Container-Bibliothek
 
std::map
Memberfunktionen
Nicht-Member-Funktionen
(bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Ableitungsregeln (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>> >
map( InputIt, InputIt, Comp = Comp(), Alloc = Alloc() )

    -> map<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>> >
map( std::initializer_list<std::pair<Key, T>>, Comp = Comp(), Alloc = Alloc() )

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

map( InputIt, InputIt, Alloc )
    -> map<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 >

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

    -> map<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>> >
map( std::from_range_t, R&&, Compare = Compare(), Alloc = Alloc() )

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

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

    -> map<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 Deduktionshilfen werden für map bereitgestellt, um die Deduktion aus einem Iterator-Bereich (Überladungen (1,3)) und std::initializer_list (Überladungen (2,4)) zu ermöglichen.
5,6) Diese Deduktionshilfen werden für map bereitgestellt, um die Deduktion aus einem std::from_range_t-Tag 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 ganzzahlige Typen als Eingabeiteratoren nicht 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 unevaluierter Operand behandelt wird.

[bearbeiten] Hinweise

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

[bearbeiten] Beispiel

Führen Sie diesen Code aus
#include <map>
 
int main()
{
    // std::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::map m1 = {std::pair{"foo", 2}, {"bar", 3}}; // guide #2
    std::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/map/deduction_guides&oldid=135254"