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
Definido en el encabezado <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) (desde 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) (desde C++23)
template < class KeyContainer, class Compare, class Allocator >

flat_set ( KeyContainer, Compare, Allocator )

- > flat_set < typename KeyContainer :: value_type , Compare, KeyContainer > ;
(3) (desde 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) (desde 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) (desde 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) (desde 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) (desde 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) (desde 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 > ,

/*asignación-alloc*/ < Allocator, ranges:: range_value_t < R >>>> ;
(9) (desde 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 > ,

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

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

- > flat_set < Key, Compare > ;
(11) (desde 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) (desde C++23)
Alias de tipos auxiliares solo para exposición
template < class InputIt >

using /*iter-val-t*/ =

typename std:: iterator_traits < InputIt > :: value_type ;
( solo para exposición* )
template < class Allocator, class T >

using /*alloc-rebind*/ =

typename std:: allocator_traits < Allocator > :: template rebind_alloc < T > ;
( solo para exposición* )

Estas guías de deducción se proporcionan para para permitir la deducción de:

1) Un contenedor y un comparador.
2) Un contenedor y un asignador.
3) Un contenedor, un comparador y un asignador.
4) La std::sorted_unique_t etiqueta, un contenedor y un comparador.
5) La etiqueta std::sorted_unique_t , un contenedor y un asignador.
6) La etiqueta std::sorted_unique_t , un contenedor, un comparador y un asignador de memoria.
7) Un rango de iteradores y un comparador.
8) La etiqueta std::sorted_unique_t , un rango de iteradores y un comparador.
9) La etiqueta std:: from_range_t , un rango input_range , un comparador y un asignador.
10) La etiqueta std:: from_range_t , un rango input_range y un asignador de memoria.
11) La std::initializer_list y un comparador.
12) La etiqueta std::sorted_unique_t , el std::initializer_list y un comparador.

Estas sobrecargas participan en la resolución de sobrecarga solo si InputIt satisface LegacyInputIterator , Alloc satisface Allocator , y Comp no satisface Allocator .

Nota: el grado en que la biblioteca determina que un tipo no satisface LegacyInputIterator no está especificado, excepto que como mínimo los tipos integrales no califican como iteradores de entrada. Del mismo modo, el grado en que determina que un tipo no satisface Allocator no está especificado, excepto que como mínimo el tipo miembro Alloc::value_type debe existir y la expresión std:: declval < Alloc & > ( ) . allocate ( std:: size_t { } ) debe estar bien formada cuando se trata como un operando no evaluado.

Ejemplo

Esta sección está incompleta
Razón: sin ejemplo