Namespaces
Variants

deduction guides for std::flat_set

From cppreference.net

C++
Containers library
std::flat_set
Member types
Member functions
Helper classes
Tags
Deduction guides
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags und Attribute unverändert bleiben müssen und die Zelleninhalte leer sind.)
Definiert in Header <flat_set>
template < class KeyContainer,

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

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

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

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

flat_set ( KeyContainer, Compare, Allocator )

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

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

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

flat_set ( std:: sorted_unique_t , KeyContainer, Allocator )
- > flat_set < typename KeyContainer :: value_type ,

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

flat_set ( std:: sorted_unique_t , KeyContainer, Compare, Allocator )

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

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

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

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

- > flat_set < /*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_set ( std:: from_range_t , R && , Compare = Compare ( ) , Allocator = Allocator ( ) )
- > flat_set < 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_set ( std:: from_range_t , R && , Allocator )
- > flat_set < ranges:: range_value_t < R > , std:: less < ranges:: range_value_t < R >> ,
std:: vector < ranges:: range_value_t < R > ,

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

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

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

flat_set ( std:: sorted_unique_t ,
std:: initializer_list < Key > , Compare = Compare ( ) )

- > flat_set < 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 Deduktion von folgenden Elementen 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_unique_t -Tag, ein Container und ein Komparator.
5) Der std::sorted_unique_t -Tag, ein Container und ein Allokator.
6) Der std::sorted_unique_t -Tag, ein 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) Der 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 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 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 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