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

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

/*tipo-mapeado-iter*/ < InputIt > , Compare > ;
(7) (desde 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) (desde 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) (desde 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) (desde 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) (desde 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) (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 InputIt >

using /*iter-key-t*/ =

std:: remove_const_t < std:: tuple_element_t < 0 , /*iter-val-t*/ < InputIt >>> ;
( solo para exposición* )
template < class InputIt >

using /*iter-mapped-t*/ =

std:: tuple_element_t < 1 , /*iter-val-t*/ < InputIt >> ;
( 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* )
template < ranges:: input_range Range >

using /*range-key-t*/ =

std:: remove_const_t < typename ranges:: range_value_t < Range > :: first_type > ;
( solo para exposición* )
template < ranges:: input_range Range >

using /*range-mapped-t*/ =

typename ranges:: range_value_t < Range > :: second_type ;
( solo para exposición* )

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

1) Un contenedor de claves, un contenedor mapeado y un comparador.
2) Un contenedor de claves, un contenedor mapeado y un asignador.
3) Un contenedor de claves, un contenedor mapeado, un comparador y un asignador.
4) La etiqueta std::sorted_unique_t , un contenedor de claves, un contenedor mapeado y un comparador.
5) La etiqueta std::sorted_unique_t , un contenedor de claves, un contenedor mapeado y un asignador.
6) La etiqueta std::sorted_unique_t , un contenedor de claves, un contenedor mapeado, un comparador y un asignador.
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