Namespaces
Variants

deduction guides for std::flat_map

From cppreference.net

C++
Containers library
std::flat_map
Member types
Member functions
Non-member functions
Helper classes
Tags
Deduction guides
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt unverändert, wie angefordert.)
Definiert in Header <flat_map>
template < class KeyContainer, class MappedContainer,

class Compare = std:: less < typename KeyContainer :: value_type > >
flat_map ( KeyContainer, MappedContainer, Compare = Compare ( ) )
- > flat_map < typename KeyContainer :: value_type ,
typename MappedContainer :: value_type ,

Compare, KeyContainer, MappedContainer > ;
(1) (seit C++23)
template < class KeyContainer, class MappedContainer, class Allocator >

flat_map ( KeyContainer, MappedContainer, Allocator )
- > flat_map < typename KeyContainer :: value_type ,
typename MappedContainer :: value_type ,
std:: less < typename KeyContainer :: value_type > ,

KeyContainer, MappedContainer > ;
(2) (seit C++23)
template < class KeyContainer, class MappedContainer,

class Compare, class Allocator >
flat_map ( KeyContainer, MappedContainer, Compare, Allocator )
- > flat_map < typename KeyContainer :: value_type ,
typename MappedContainer :: value_type ,

Compare, KeyContainer, MappedContainer > ;
(3) (seit C++23)
template < class KeyContainer, class MappedContainer,

class Compare = std:: less < typename KeyContainer :: value_type > >
flat_map ( std:: sorted_unique_t , KeyContainer, MappedContainer,
Compare = Compare ( ) )
- > flat_map < typename KeyContainer :: value_type ,
typename MappedContainer :: value_type ,

Compare, KeyContainer, MappedContainer > ;
(4) (seit C++23)
template < class KeyContainer, class MappedContainer, class Allocator >

flat_map ( std:: sorted_unique_t , KeyContainer, MappedContainer,
Allocator )
- > flat_map < typename KeyContainer :: value_type ,
typename MappedContainer :: value_type ,
std:: less < typename KeyContainer :: value_type > ,

KeyContainer, MappedContainer > ;
(5) (seit C++23)
template < class KeyContainer, class MappedContainer,

class Compare, class Allocator >
flat_map ( std:: sorted_unique_t , KeyContainer, MappedContainer,
Compare, Allocator )
- > flat_map < typename KeyContainer :: value_type ,
typename MappedContainer :: value_type ,

Compare, KeyContainer, MappedContainer > ;
(6) (seit C++23)
template < class InputIt,

class Compare = std:: less < /*iter-key-t*/ < InputIt >> >
flat_map ( InputIt, InputIt, Compare = Compare ( ) )
- > flat_map < /*iter-key-t*/ < InputIt > ,

/*iter-mapped-t*/ < InputIt > , Compare > ;
(7) (seit C++23)
template < class InputIt,

class Compare = std:: less < /*iter-key-t*/ < InputIt >> >
flat_map ( std:: sorted_unique_t , InputIt, InputIt,
Compare = Compare ( ) )
- > flat_map < /*iter-key-t*/ < InputIt > ,

/*iter-mapped-t*/ < InputIt > , Compare > ;
(8) (seit C++23)
template < ranges:: input_range R,

class Compare = std:: less < /*range-key-t*/ < R >> ,
class Allocator = allocator < byte > >
flat_map ( std:: from_range_t , R && , Compare = Compare ( ) ,
Allocator = Allocator ( ) )
- > flat_map < /*range-key-t*/ < R > , /*range-mapped-t*/ < R > , Compare,
std:: vector < /*range-key-t*/ < R > ,
/*alloc-rebind*/ < Allocator,
/*range-key-t*/ < R >>> ,
std:: vector < /*range-mapped-t*/ < R > ,
/*alloc-rebind*/ < Allocator,

/*range-mapped-t*/ < R >>>> ;
(9) (seit C++23)
template < ranges:: input_range R, class Allocator >

flat_map ( std:: from_range_t , R && , Allocator )
- > flat_map < /*range-key-t*/ < R > , /*range-mapped-t*/ < R > ,
std:: less < /*range-key-t*/ < R >> ,
std:: vector < /*range-key-t*/ < R > ,
/*alloc-rebind*/ < Allocator,
/*range-key-t*/ < R >>> ,
std:: vector < /*range-mapped-t*/ < R > ,
/*alloc-rebind*/ < Allocator,

/*range-mapped-t*/ < R >>>> ;
(10) (seit C++23)
template < class Key, class T, class Compare = std:: less < Key > >

flat_map ( std:: initializer_list < pair < Key, T >> , Compare = Compare ( ) )

- > flat_map < Key, T, Compare > ;
(11) (seit C++23)
template < class Key, class T, class Compare = std:: less < Key > >

flat_map ( std:: sorted_unique_t , std:: initializer_list < pair < Key, T >> ,
Compare = Compare ( ) )

- > flat_map < Key, T, Compare > ;
(12) (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 >>> ;
( exposition only* )
template < class InputIt >

using /*iter-mapped-t*/ =

std:: tuple_element_t < 1 , /*iter-val-t*/ < InputIt >> ;
( Nur zur Darstellung* )
template < class Allocator, class T >

using /*alloc-rebind*/ =

typename std:: allocator_traits < Allocator > :: template rebind_alloc < T > ;
( Nur zur Darstellung* )
template < ranges:: input_range Range >

using /*range-key-t*/ =

std:: remove_const_t < typename ranges:: range_value_t < Range > :: first_type > ;
( Nur zur Darstellung* )
template < ranges:: input_range Range >

using /*range-mapped-t*/ =

typename ranges:: range_value_t < Range > :: second_type ;
( nur zur Darstellung* )

Diese Deduktionsführer werden für bereitgestellt, um die Ableitung von Folgendem zu ermöglichen:

1) Ein Schlüssel-Container, ein Abbildungs-Container und ein Komparator.
2) Ein Schlüssel-Container, ein abgebildeter Container und ein Allokator.
3) Ein Schlüssel-Container, ein Abbildungs-Container, ein Komparator und ein Allokator.
4) Der std::sorted_unique_t -Tag, ein Schlüssel-Container, ein Abbildungs-Container und ein Komparator.
5) Der std::sorted_unique_t -Tag, ein Schlüssel-Container, ein Abbildungs-Container und ein Allokator.
6) Der std::sorted_unique_t -Tag, ein Schlüssel-Container, ein Abbildungs-Container, ein Komparator und ein Allokator.
7) Ein Iteratorbereich und ein Komparator.
8) Der std::sorted_unique_t -Tag, ein Iteratorbereich und ein Komparator.
9) Der std:: from_range_t Tag, ein input_range Bereich, ein Vergleichsobjekt und ein Allokator.
10) Der std:: from_range_t Tag, ein input_range Bereich und ein Allokator.
11) Die std::initializer_list und ein Komparator.
12) Der std::sorted_unique_t -Tag, die std::initializer_list und ein Komparator.

Diese Überladungen nehmen nur dann an der Überladungsauflösung teil, wenn InputIt die Anforderungen eines LegacyInputIterator erfüllt, Alloc die Anforderungen eines Allocator erfüllt, und Comp nicht die Anforderungen eines 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 integrale Typen nicht als Input-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.

Beispiel

Dieser Abschnitt ist unvollständig
Grund: Kein Beispiel