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

See More

 

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

De secuencias

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

deque

forward_list (C++11)

list

Asociativos

set

multiset

map

multimap

Asociativos no ordenados

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptadores

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Vistas

span (C++20)

mdspan (C++23)

Tablas

Invalidación de iteradores

Tabla de funciones miembro

Tabla de funciones no miembro

 

std::flat_map

Tipos miembro
Funciones miembro
flat_map::flat_map	flat_map::operator=
Acceso a elementos
flat_map::at	flat_map::operator[]
Iteradores
flat_map::beginflat_map::cbegin flat_map::endflat_map::cend	flat_map::rbeginflat_map::crbegin flat_map::rendflat_map::crend
Capacidad
flat_map::size flat_map::max_size	flat_map::empty
Modificadores
flat_map::clear flat_map::erase flat_map::swap flat_map::emplace flat_map::extract flat_map::replace	flat_map::insert flat_map::insert_range flat_map::insert_or_assign flat_map::emplace_hint flat_map::try_emplace
Búsqueda
flat_map::count flat_map::find flat_map::contains	flat_map::equal_range flat_map::lower_bound flat_map::upper_bound
Observadores
flat_map::key_comp flat_map::keys	flat_map::value_comp flat_map::values
Funciones no miembro
operator==operator<=> (C++23)(C++23)	swap(std::flat_map) (C++23) erase_if(std::flat_map) (C++23)
Clases auxiliares
uses_allocator<std::flat_map> (C++23)
Etiquetas
sorted_unique (C++23)	sorted_unique_t (C++23)
Guías de deducción

 

<tbody> </tbody>

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, {{#pad:|8}} typename MappedContainer::value_type, {{#pad:|8}} 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, {{#pad:|8}} typename MappedContainer::value_type, {{#pad:|8}} std::less<typename KeyContainer::value_type>, {{#pad:|8}} 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, {{#pad:|8}} typename MappedContainer::value_type, {{#pad:|8}} 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, {{#pad:|8}} Compare = Compare() ) -> flat_map<typename KeyContainer::value_type, {{#pad:|8}} typename MappedContainer::value_type, {{#pad:|8}} Compare, KeyContainer, MappedContainer>;	(4)	(desde C++23)
template< class KeyContainer, class MappedContainer, class Allocator > flat_map( std::sorted_equivalent_t, KeyContainer, MappedContainer, {{#pad:|8}} Allocator ) -> flat_map<typename KeyContainer::value_type, {{#pad:|8}} typename MappedContainer::value_type, {{#pad:|8}} std::less<typename KeyContainer::value_type>, {{#pad:|8}} KeyContainer, MappedContainer>;	(5)	(desde C++23)
template< class KeyContainer, class MappedContainer, class Compare, class Allocator> flat_map( std::sorted_equivalent_t, KeyContainer, MappedContainer, {{#pad:|8}} Compare, Allocator ) -> flat_map<typename KeyContainer::value_type, {{#pad:|8}} typename MappedContainer::value_type, {{#pad:|8}} 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>, {{#pad:|8}} /*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, {{#pad:|8}} Compare = Compare() ) -> flat_map</*iter-key-type*/<InputIter>, {{#pad:|8}} /*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(), {{#pad:|8}} Allocator = Allocator() ) -> flat_map</*range-key-type*/<R>, /*range-mapped-type*/<R>, Compare, {{#pad:|8}} std::vector</*range-key-type*/<R>, {{#pad:|8}} /*alloc-rebind*/<Allocator, {{#pad:|8}} /*range-key-type*/<R>>>, {{#pad:|8}} std::vector</*range-mapped-type*/<R>, {{#pad:|8}} /*alloc-rebind*/<Allocator, {{#pad:|8}} /*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>, {{#pad:|8}} std::less</*range-key-type*/<R>>, {{#pad:|8}} std::vector</*range-key-type*/<R>, {{#pad:|8}} /*alloc-rebind*/<Allocator, {{#pad:|8}} /*range-key-type*/<R>>>, {{#pad:|8}} std::vector</*range-mapped-type*/<R>, {{#pad:|8}} /*alloc-rebind*/<Allocator, {{#pad:|8}} /*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>>, {{#pad:|8}} 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.