Espacios de nombres
Variantes
Acciones

Guías de deducción para std::flat_map

De cppreference.com
< cpp‎ | container‎ | flat map

[edit template]
 
C++
Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas
 
Biblioteca de contenedores
 
std::flat_map
Tipos miembro
Funciones miembro
Acceso a elementos
Iteradores
Capacidad
Modificadores
Búsqueda
Observadores
Funciones no miembro
(C++23)(C++23)
Clases auxiliares
(C++23)
Etiquetas
(C++23)    
Guías de deducción
 
Definido en el archivo de 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_equivalent_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_equivalent_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_equivalent_t, KeyContainer, MappedContainer,
          Compare, Allocator )
    -> flat_map<typename KeyContainer::value_type,
                typename MappedContainer::value_type,

                Compare, KeyContainer, MappedContainer>;
 (6) (desde C++23)
template< class InputIter,

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

                /*iter-mapped-type*/<InputIter>, Compare>;
 (7) (desde C++23)
template< class InputIter,

          class Compare = std::less</*iter-key-type*/<InputIter>> >
flat_map( std::sorted_equivalent_t, InputIter, InputIter,
          Compare = Compare() )
    -> flat_map</*iter-key-type*/<InputIter>,

                /*iter-mapped-type*/<InputIter>, Compare>;
 (8) (desde C++23)
template< ranges::input_range R,

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

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

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

                                             /*range-mapped-type*/<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_equivalent_t, std::initializer_list<pair<Key, T>>,
          Compare = Compare() )

    -> flat_map<Key, T, Compare>;
 (12) (desde C++23)

Estas guías de deducción se proporcionan para 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_equivalent_t, un contenedor de claves, un contenedor mapeado y un comparador.
5) La etiqueta std::sorted_equivalent_t, un contenedor de claves, un contenedor mapeado y un asignador.
6) La etiqueta std::sorted_equivalent_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_equivalent_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.
11) La std::initializer_list y un comparador.
12) La etiqueta std::sorted_equivalent_t, la std::initializer_list y un comparador.

Estas sobrecargas solo participan en la resolución de sobrecargas si InputIt satisface IteradorDeEntradaLegado, Alloc satisface Asignador, y Comp no satisface Asignador.

Nota: no se especifica hasta qué grado la biblioteca determina que un tipo no satisface a IteradorDeEntradaLegado, excepto que, como mínimo, los tipos enteros no califican como iteradores de entrada. Del mismo modo, no se especifica en qué medida se determina que un tipo no satisface a Allocator, 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 trate como un operando no evaluado.

[editar] Ejemplo

Esta sección está incompleta
Razón: sin ejemplo
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/container/flat_map/deduction_guides&oldid=46063»