Namespaces
Variants

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

    From es.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 ).

    Contenido

    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, los punteros y los iteradores que originalmente se referían a elementos en other siguen siendo válidos, pero se refieren a elementos que ahora están en *this. El estándar actual ofrece esta garantía 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)