Namespaces
Variants

std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>:: flat_map

From cppreference.net

C++
Containers library
std::flat_map
Member types
Member functions
Non-member functions
Helper classes
Tags
Deduction guides
flat_map ( )
: flat_map ( key_compare ( ) ) { }
(1) (desde C++23)
template < class Allocator >
flat_map ( const flat_map & , const Allocator & alloc ) ;
(2) (desde C++23)
template < class Allocator >
flat_map ( flat_map && , const Allocator & alloc ) ;
(3) (desde C++23)
flat_map ( key_container_type key_cont, mapped_container_type mapped_cont,
const key_compare & comp = key_compare ( ) ) ;
(4) (desde C++23)
template < class Allocator >

flat_map ( const key_container_type & key_cont,
const mapped_container_type & mapped_cont,

const Allocator & alloc ) ;
(5) (desde C++23)
template < class Allocator >

flat_map ( const key_container_type & key_cont,
const mapped_container_type & mapped_cont,

const key_compare & comp, const Allocator & alloc ) ;
(6) (desde C++23)
flat_map ( std:: sorted_unique_t , key_container_type key_cont,

mapped_container_type mapped_cont,

const key_compare & comp = key_compare ( ) ) ;
(7) (desde C++23)
template < class Allocator >

flat_map ( std:: sorted_unique_t , const key_container_type & key_cont,

const mapped_container_type & mapped_cont, const Allocator & alloc ) ;
(8) (desde C++23)
template < class Allocator >

flat_map ( std:: sorted_unique_t , const key_container_type & key_cont,
const mapped_container_type & mapped_cont,

const key_compare & comp, const Allocator & alloc ) ;
(9) (desde C++23)
explicit flat_map ( const key_compare & comp )
: c ( ) , compare ( comp ) { }
(10) (desde C++23)
template < class Allocator >
flat_map ( const key_compare & comp, const Allocator & alloc ) ;
(11) (desde C++23)
template < class Allocator >
explicit flat_map ( const Allocator & alloc ) ;
(12) (desde C++23)
template < class InputIter >

flat_map ( InputIter first, InputIter last,
const key_compare & comp = key_compare ( ) )

: c ( ) , compare ( comp ) ;
(13) (desde C++23)
template < class InputIter, class Allocator >

flat_map ( InputIter first, InputIter last,

const key_compare & comp, const Allocator & alloc ) ;
(14) (desde C++23)
template < class InputIter, class Allocator >
flat_map ( InputIter first, InputIter last, const Allocator & alloc ) ;
(15) (desde C++23)
template < container-compatible-range < value_type > R >

flat_map ( std:: from_range_t , R && rg, const key_compare & comp )

: flat_map ( comp ) ;
(16) (desde C++23)
template < container-compatible-range < value_type > R >

flat_map ( std:: from_range_t fr, R && rg )

: flat_map ( fr, std:: forward < R > ( rg ) , key_compare ( ) ) { }
(17) (desde C++23)
template < container-compatible-range < value_type > R, class Allocator >
flat_map ( std:: from_range_t , R && rg, const Allocator & alloc ) ;
(18) (desde C++23)
template < container-compatible-range < value_type > R, class Allocator >

flat_map ( std:: from_range_t , R && rg, const key_compare & comp,

const Allocator & alloc ) ;
(19) (desde C++23)
template < class InputIter >

flat_map ( std:: sorted_unique_t s, InputIter first, InputIter last,
const key_compare & comp = key_compare ( ) )

: c ( ) , compare ( comp ) ;
(20) (desde C++23)
template < class InputIter, class Allocator >

flat_map ( std:: sorted_unique_t s, InputIter first, InputIter last,

const key_compare & comp, const Allocator & alloc ) ;
(21) (desde C++23)
template < class InputIter, class Allocator >

flat_map ( std:: sorted_unique_t s, InputIter first, InputIter last,

const Allocator & alloc ) ;
(22) (desde C++23)
flat_map ( std:: initializer_list < value_type > init,

const key_compare & comp = key_compare ( ) )

: flat_map ( init. begin ( ) , init. end ( ) , comp ) { }
(23) (desde C++23)
template < class Allocator >

flat_map ( std:: initializer_list < value_type > init, const key_compare & comp,

const Allocator & alloc ) ;
(24) (desde C++23)
template < class Allocator >
flat_map ( std:: initializer_list < value_type > init, const Allocator & alloc ) ;
(25) (desde C++23)
flat_map ( std:: sorted_unique_t s, std:: initializer_list < value_type > init,

const key_compare & comp = key_compare ( ) )

: flat_map ( s, init. begin ( ) , init. end ( ) , comp ) { }
(26) (desde C++23)
template < class Allocator >

flat_map ( std:: sorted_unique_t s, std:: initializer_list < value_type > init,

const key_compare & comp, const Allocator & alloc ) ;
(27) (desde C++23)
template < class Allocator >

flat_map ( std:: sorted_unique_t s, std:: initializer_list < value_type > init,

const Allocator & alloc ) ;
(28) (desde C++23)

Construye un nuevo adaptador de contenedor a partir de diversas fuentes de datos y opcionalmente utilizando el objeto de función de comparación proporcionado por el usuario comp y/o el asignador alloc .

1) Un constructor predeterminado. Construye un adaptador de contenedor vacío.
2) Un copy constructor . Construye c con la copia de los contenidos de other. c y compare con other. compare . Consulte la nota de uso del asignador a continuación.
3) Un move constructor . Construye el adaptador de contenedor con los contenidos de other usando semántica de movimiento. Consulte la nota de uso del asignador a continuación.
4) Primero, inicializa c.keys con std :: move ( key_cont ) , c.values con std :: move ( mapped_cont ) , y compare con comp . Luego ordena el rango subyacente [ begin ( ) , end ( ) ) con respecto a value_comp() . Finalmente, elimina los elementos duplicados como si fuera por:
auto zv = views:: zip ( c. keys , c. values ) ;
auto it = ranges:: unique ( zv, key_equiv ( compare ) ) . begin ( ) ;
auto dist = distance ( zv. begin ( ) , it ) ;
c. keys . erase ( c. keys . begin ( ) + dist, c. keys . end ( ) ) ;
c. values . erase ( c. values . begin ( ) + dist, c. values . end ( ) ) ; .
5) Igual que (4) , equivalente a flat_map ( key_cont, mapped_cont ) ; . Consulte la nota de uso del asignador a continuación.
6) Igual que (4) , equivalente a flat_map ( key_cont, mapped_cont, comp ) ; . Consulte la nota de uso del asignador a continuación.
7) Inicializa c.keys con std :: move ( key_cont ) , c.values con std :: move ( mapped_cont ) , y compare con comp .
8) Igual que (7) , equivalente a flat_map ( s, key_cont, mapped_cont ) ; . Consulte la nota de uso del asignador a continuación.
9) Igual que (7) , equivalente a flat_map ( s, key_cont, mapped_cont, comp ) ; . Ver nota de uso del asignador abajo.
10) Construye un adaptador de contenedor vacío.
11,12) Construye un adaptador de contenedor vacío. Consulte la nota de uso del asignador a continuación.
13) Construye el adaptador de contenedor con los contenidos del rango [ first , last ) , equivalente a insert ( first, last ) ; .
14,15) Igual que (13) . Consulte la nota de uso del asignador a continuación.
16) Construye el adaptador de contenedor con los contenidos del rango rg . Primero, utiliza (10) como constructor delegado . Luego inicializa c con los contenidos de rg como si fuera mediante insert_range ( std:: forward < R > ( rg ) ) ; .
17) Igual que (16) usándolo como delegating constructor .
18,19) Igual que (16) . Ver nota de uso del asignador abajo.
20) Construye los contenedores subyacentes con el contenido del rango [ first , last ) como si fuera mediante insert ( first, last ) .
21,22) Igual que (20) . Consulte la nota de uso del asignador a continuación.
23) Un constructor de lista de inicialización . Construye el contenedor subyacente con el contenido de la lista de inicialización init , usando (13) como constructor delegado .
24,25) Igual que (23) . Consulte la nota de uso del asignador a continuación.
26) Un constructor de lista de inicialización . Construye el contenedor subyacente con el contenido de la lista de inicialización init , usando (20) como constructor delegado .
27,28) Guardar como (26) . Ver nota de uso del asignador abajo.

Nota para las sobrecargas (13-15,20-22) : Si [ first , last ) no es un rango válido , el comportamiento es indefinido.

Note for overloads (4-6,13-19,23-25) : If multiple elements in the range have keys that compare equivalent, it is unspecified which element is inserted (pending LWG2844 ).

Contenidos

Nota de uso del asignador

Los constructores (2,3,5,6,8,9,11,12,14,15,17,19,21,22,24,25,27,28) son equivalentes a los constructores correspondientes sin asignador, excepto que los contenedores subyacentes c.keys y c.values se construyen mediante construcción uses-allocator . Estas sobrecargas participan en la resolución de sobrecarga solo si std:: uses_allocator_v < container_type, Allocator > es true .

Parámetros

key_cont - un contenedor que se utilizará como fuente para inicializar el contenedor subyacente de claves
mapped_cont - un contenedor que se utilizará como fuente para inicializar el contenedor subyacente de valores
other - otro flat_map que se utilizará como fuente para inicializar los elementos de los contenedores subyacentes
alloc - un asignador de memoria para usar en todas las asignaciones de memoria de los contenedores subyacentes
comp - un objeto función que se utilizará para todas las comparaciones de claves
first, last - el par de iteradores que define el rango fuente de elementos a copiar
init - una lista de inicialización para inicializar los elementos de los contenedores subyacentes
rg - un rango compatible con contenedor (es decir, un input_range cuyos elementos son convertibles a value_type ) que se utilizará como fuente para inicializar los contenedores subyacentes
fr - una etiqueta de desambiguación que indica que el miembro contenido debe construirse por rango
s - una etiqueta de desambiguación que indica que la secuencia de entrada está ordenada con respecto a value_comp() y todos sus elementos son únicos
Requisitos de tipo
-
InputIt debe cumplir con los requisitos de LegacyInputIterator .
-
Compare debe cumplir con los requisitos de Compare .
-
Allocator debe cumplir con los requisitos de Allocator .

Complejidad

1) Constante.
2) Lineal en tamaño de other .
3) Igual que el constructor de movimiento correspondiente del contenedor envuelto, es decir, constante o lineal en el tamaño de cont .
4-6) Lineal en N si cont está ordenado con respecto a value_comp() , de lo contrario 𝓞(N·log(N)) , donde N es el valor de key_cont. size ( ) antes de esta llamada.
7-9) Igual que el constructor de movimiento correspondiente del contenedor envuelto, es decir, constante o lineal en el tamaño de cont .
10-12) Constante.
13-15) Lineal en N si el rango de entrada [ first , last ) está ordenado con respecto a value_comp() , de lo contrario 𝓞(N·log(N)) , donde N es el valor de key_cont. size ( ) antes de esta llamada.
16-19) Lineal en N si el rango de entrada rg está ordenado con respecto a value_comp() , de lo contrario 𝓞(N·log(N)) , donde N es el valor de key_cont. size ( ) antes de esta llamada.
20-22) Lineal en el tamaño de [ first , last ) .
23-25) Lineal en N si los elementos de init están ordenados con respecto a value_comp() , de lo contrario 𝓞(N·log(N)) , donde N es el valor de key_cont. size ( ) antes de esta llamada.
26-28) Lineal en tamaño de init .

Excepciones

Las llamadas a Allocator::allocate pueden lanzar excepciones.

Notas

Después de la construcción por movimiento del contenedor (sobrecarga ( 3 ) ), las referencias, punteros e iteradores (excepto el iterador final) a other permanecen válidos, pero se refieren a elementos que ahora están en * this . El estándar actual garantiza esto mediante la declaración general en [container.reqmts]/67 , y se está considerando una garantía más directa a través de LWG issue 2321 .

Ejemplo

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

Véase también

asigna valores al adaptador de contenedor
(función miembro pública)