Namespaces
Variants

deduction guides for std::flat_multiset

From cppreference.net

C++
Containers library
std::flat_multiset
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. Bei tatsächlichem Textinhalt würde dieser gemäß den Vorgaben übersetzt werden.)
Definiert in Header <flat_set>
template < class KeyContainer,

class Compare = std:: less < typename KeyContainer :: value_type > >
flat_multiset ( KeyContainer, Compare = Compare ( ) )

- > flat_multiset < typename KeyContainer :: value_type , Compare, KeyContainer > ;
(1) (seit C++23)
template < class KeyContainer, class Allocator >

flat_multiset ( KeyContainer, Allocator )
- > flat_multiset < typename KeyContainer :: value_type ,

std:: less < typename KeyContainer :: value_type > , KeyContainer > ;
(2) (seit C++23)
template < class KeyContainer, class Compare, class Allocator >

flat_multiset ( KeyContainer, Compare, Allocator )

- > flat_multiset < typename KeyContainer :: value_type , Compare, KeyContainer > ;
(3) (seit C++23)
template < class KeyContainer,

class Compare = std:: less < typename KeyContainer :: value_type > >
flat_multiset ( std:: sorted_equivalent_t , KeyContainer, Compare = Compare ( ) )

- > flat_multiset < typename KeyContainer :: value_type , Compare, KeyContainer > ;
(4) (seit C++23)
template < class KeyContainer, class Allocator >

flat_multiset ( std:: sorted_equivalent_t , KeyContainer, Allocator )
- > flat_multiset < typename KeyContainer :: value_type ,

std:: less < typename KeyContainer :: value_type > , KeyContainer > ;
(5) (seit C++23)
template < class KeyContainer, class Compare, class Allocator >

flat_multiset ( std:: sorted_equivalent_t , KeyContainer, Compare, Allocator )

- > flat_multiset < typename KeyContainer :: value_type , Compare, KeyContainer > ;
(6) (seit C++23)
template < class InputIt,

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

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

class Compare = std:: less < /*iter-val-t*/ < InputIt >> >
flat_multiset ( std:: sorted_equivalent_t , InputIt, InputIt, Compare = Compare ( ) )

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

class Compare = std:: less < ranges:: range_value_t < R >> ,
class Allocator = std:: allocator < ranges:: range_value_t < R >> >
flat_multiset ( std:: from_range_t , R && , Compare = Compare ( ) , Allocator = Allocator ( ) )
- > flat_multiset < ranges:: range_value_t < R > , Compare,
std:: vector < ranges:: range_value_t < R > ,

/*Allokator-Rebind*/ < Allocator, ranges:: range_value_t < R >>>> ;
(9) (seit C++23)
template < ranges:: input_range R, class Allocator >

flat_multiset ( std:: from_range_t , R && , Allocator )
- > flat_multiset < ranges:: range_value_t < R > , std:: less < ranges:: range_value_t < R >> ,
std:: vector < ranges:: range_value_t < R > ,

/*alloc-rebind*/ < Allocator, ranges:: range_value_t < R >>>> ;
(10) (seit C++23)
template < class Key, class Compare = std:: less < Key > >

flat_multiset ( std:: initializer_list < Key > , Compare = Compare ( ) )

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

flat_multiset ( std:: sorted_equivalent_t ,
std:: initializer_list < Key > , Compare = Compare ( ) )

- > flat_multiset < Key, 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 Allocator, class T >

using /*alloc-rebind*/ =

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

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

1) Ein Container und ein Komparator.
2) Ein Container und ein Allocator.
3) Ein Container, ein Komparator und ein Allokator.
4) Der std::sorted_equivalent_t Tag, ein Container und ein Komparator.
5) Der std::sorted_equivalent_t Tag, ein Container und ein Allokator.
6) Der std::sorted_equivalent_t -Tag, ein Container, ein Komparator und ein Allokator.
7) Ein Iteratorbereich und ein Komparator.
8) Der std::sorted_equivalent_t -Tag, ein Iteratorbereich und ein Komparator.
9) Der std:: from_range_t Tag, ein input_range Bereich, ein Vergleichsobjekt und ein Allokator.
10) Das std:: from_range_t Tag, ein input_range Bereich und ein Allokator.
11) Die std::initializer_list und ein Komparator.
12) Der std::sorted_equivalent_t -Tag, die std::initializer_list und ein Komparator.

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 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