Namespaces
Variants

deduction guides for std::multimap

From cppreference.net

C++
Containers library
std::multimap
Member functions
Non-member functions
Deduction guides (C++17)
**Übersetzungsdetails:** - "(since C++23)" → "(seit C++23)" - "exposition only" → "nur zur Darstellung" - Der Titeltext wurde entsprechend übersetzt: "This definition is for illustration purposes only..." → "Diese Definition dient nur zur Veranschaulichung..." - Alle HTML-Tags, Attribute und Code-Blöcke wurden unverändert beibehalten - C++-spezifische Begriffe (template, using, typename, ranges::input_range, etc.) wurden nicht übersetzt (Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Bei tatsächlichem Textinhalt würde dieser gemäß den Vorgaben übersetzt werden.)
Definiert im 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 > ,

multimap std:: less < /*range-key-t*/ < R >> , Alloc > ;
(6) (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 >> ;
( exposition only* )
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-4) Diese Deduction Guides werden für multimap bereitgestellt, um die Deduktion aus einem Iteratorbereich (Overloads (1,3) ) und std::initializer_list (Overloads (2,4) ) zu ermöglichen.
5,6) Diese Deduktionsführer werden für multimap bereitgestellt, um die Deduktion 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, und Comp nicht die Anforderungen Allocator erfüllt.

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 Ganzzahltypen nicht als Eingabe-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.

Hinweise

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

Beispiel

Diesen Code ausführen 
#include <map>
int main()
{
    // std::multimap m1 = {{"foo", 1}, {"bar", 2}};
        // Fehler: Initialisierungsliste hat keinen Typ; kann
        // pair<Key, T> nicht von {"foo", 1} oder {"bar", 2} ableiten
    std::multimap m1 = {std::pair{"foo", 2}, {"bar", 3}}; // Guide #2
    std::multimap m2(m1.begin(), m1.end()); // Guide #1
}

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