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

 

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_multimap

Tipos miembro

Funciones miembro

flat_multimap::flat_multimap    flat_multimap::operator= Modificadores flat_multimap::clear flat_multimap::erase flat_multimap::swap flat_multimap::extract flat_multimap::replace flat_multimap::insert flat_multimap::insert_range flat_multimap::emplace flat_multimap::emplace_hint Búsqueda flat_multimap::count flat_multimap::find flat_multimap::contains flat_multimap::equal_range flat_multimap::lower_bound flat_multimap::upper_bound Iteradores flat_multimap::beginflat_multimap::cbegin flat_multimap::endflat_multimap::cend flat_multimap::rbeginflat_multimap::crbegin flat_multimap::rendflat_multimap::crend Capacidad flat_multimap::size flat_multimap::max_size flat_multimap::empty Observadores flat_multimap::key_comp flat_multimap::keys flat_multimap::value_comp flat_multimap::values

Funciones no miembro

swap(std::flat_multimap) erase_if(std::flat_multimap)     operator==operator<=>

Clases auxiliares

uses_allocator<std::flat_multimap>

Etiquetas

sorted_equivalent          sorted_equivalent_t

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_multimap( KeyContainer, MappedContainer, Compare = Compare())     -> flat_multimap<typename KeyContainer::value_type,                      typename MappedContainer::value_type,                      Compare, KeyContainer, MappedContainer>;	(1)	(desde C++23)
template<class KeyContainer, class MappedContainer, class Allocator > flat_multimap( KeyContainer, MappedContainer, Allocator )     -> flat_multimap<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_multimap( KeyContainer, MappedContainer, Compare, Allocator )     -> flat_multimap<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_multimap(std::sorted_equivalent_t, KeyContainer, MappedContainer,                Compare = Compare())     -> flat_multimap<typename KeyContainer::value_type,                      typename MappedContainer::value_type,                      Compare, KeyContainer, MappedContainer>;	(4)	(desde C++23)
template<class KeyContainer, class MappedContainer, class Allocator > flat_multimap(std::sorted_equivalent_t, KeyContainer, MappedContainer,                Allocator )     -> flat_multimap<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_multimap(std::sorted_equivalent_t, KeyContainer, MappedContainer,                Compare, Allocator )     -> flat_multimap<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_multimap( InputIter, InputIter, Compare = Compare())     -> flat_multimap</*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_multimap(std::sorted_equivalent_t, InputIter, InputIter,                Compare = Compare())     -> flat_multimap</*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_multimap(std::from_range_t, R&&, Compare = Compare(),                Allocator = Allocator())     -> flat_multimap</*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_multimap(std::from_range_t, R&&, Allocator )     -> flat_multimap</*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_multimap(std::initializer_list<pair<Key, T>>, Compare = Compare())     -> flat_multimap<Key, T, Compare>;	(11)	(desde C++23)
template<class Key, class T, class Compare =std::less<Key>> flat_multimap(std::sorted_equivalent_t, std::initializer_list<pair<Key, T>>,                Compare = Compare())     -> flat_multimap<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.