std::flat_set<Key,Compare,KeyContainer>::flat_set - cppreference.com

flat_set() : flat_set(key_compare()) { }	(1)	(desde C++23)
template< class Allocator > flat_set( const flat_set& other, const Allocator& alloc );	(2)	(desde C++23)
template< class Allocator > flat_set( flat_set&& other, const Allocator& alloc );	(3)	(desde C++23)
explicit flat_set( container_type cont, {{#pad:|8}} const key_compare& comp = key_compare() );	(4)	(desde C++23)
template< class Allocator > flat_set( const container_type& cont, const Allocator& alloc );	(5)	(desde C++23)
template< class Allocator > flat_set( const container_type& cont, const key_compare& comp, {{#pad:|8}} const Allocator& alloc );	(6)	(desde C++23)
flat_set( std::sorted_equivalent_t s, container_type cont, {{#pad:|8}} const key_compare& comp = key_compare() ) : c(std::move(cont)), compare(comp) { }	(7)	(desde C++23)
template< class Allocator > flat_set( std::sorted_equivalent_t s, const container_type& cont, {{#pad:|8}} const Allocator& alloc );	(8)	(desde C++23)
template< class Allocator > flat_set( std::sorted_equivalent_t s, const container_type& cont, {{#pad:|8}} const key_compare& comp, const Allocator& alloc );	(9)	(desde C++23)
explicit flat_set( const key_compare& comp ) : c(), compare(comp) { }	(10)	(desde C++23)
template< class Allocator > flat_set( const key_compare& comp, const Allocator& alloc );	(11)	(desde C++23)
template< class Allocator > explicit flat_set( const Allocator& alloc );	(12)	(desde C++23)
template< class InputIter > flat_set( InputIter first, InputIter last, {{#pad:|8}} const key_compare& comp = key_compare() ) : c(), compare(comp);	(13)	(desde C++23)
template< class InputIter, class Allocator > flat_set( InputIter first, InputIter last, {{#pad:|8}} const key_compare& comp, const Allocator& alloc );	(14)	(desde C++23)
template< class InputIter, class Allocator > flat_set( InputIter first, InputIter last, const Allocator& alloc );	(15)	(desde C++23)
template< container-compatible-range<value_type> R > flat_set( std::from_range_t, R&& rg, const key_compare& comp ) : flat_set(comp);	(16)	(desde C++23)
template< container-compatible-range<value_type> R > flat_set( std::from_range_t fr, R&& rg ) : flat_set( fr, std::forward<R>(rg), key_compare() ) { }	(17)	(desde C++23)
template< container-compatible-range<value_type> R, class Allocator > flat_set( std::from_range_t, R&& rg, const Allocator& alloc );	(18)	(desde C++23)
template< container-compatible-range<value_type> R, class Allocator > flat_set( std::from_range_t, R&& rg, const key_compare& comp, {{#pad:|8}} const Allocator& alloc );	(19)	(desde C++23)
template< class InputIter > flat_set( std::sorted_equivalent_t s, InputIter first, InputIter last, {{#pad:|8}} const key_compare& comp = key_compare() ) : c(first, last), compare(comp) { }	(20)	(desde C++23)
template< class InputIter, class Allocator > flat_set( std::sorted_equivalent_t s, InputIter first, InputIter last, {{#pad:|8}} const key_compare& comp, const Allocator& alloc );	(21)	(desde C++23)
template< class InputIter, class Allocator > flat_set( std::sorted_equivalent_t s, InputIter first, InputIter last, {{#pad:|8}} const Allocator& alloc );	(22)	(desde C++23)
flat_set( std::initializer_list<value_type> init, {{#pad:|8}} const key_compare& comp = key_compare() ) : flat_set(init.begin(), init.end(), comp) { }	(23)	(desde C++23)
template< class Allocator > flat_set( std::initializer_list<value_type> init, const key_compare& comp, {{#pad:|8}} const Allocator& alloc );	(24)	(desde C++23)
template< class Allocator > flat_set( std::initializer_list<value_type> init, const Allocator& alloc );	(25)	(desde C++23)
flat_set( std::sorted_equivalent_t s, std::initializer_list<value_type> init, {{#pad:|8}} const key_compare& comp = key_compare() ) : flat_set(s, init.begin(), init.end(), comp) { }	(26)	(desde C++23)
template< class Allocator > flat_set( std::sorted_equivalent_t s, std::initializer_list<value_type> init, {{#pad:|8}} const key_compare& comp, const Allocator& alloc );	(27)	(desde C++23)
template< class Allocator > flat_set( std::sorted_equivalent_t s, std::initializer_list<value_type> init, {{#pad:|8}} const Allocator& alloc );	(28)	(desde C++23)

Construye un nuevo adaptador de contenedor a partir de una variedad de fuentes de datos y, opcionalmente, proporciona un objeto de función de comparación comp y/o un asignador alloc.

1) Un constructor por defecto. Construye un adaptador de contenedor vacío.

2) Un constructor de copia. Construye c con la copia del contenido de other.c y compare con other.compare. Véase la nota de uso de asignador a continuación.

3) Un constructor de movimiento. Construye el adaptador de contenedor con el contenido de other utilizando la semántica de movimiento. Véase la nota de uso de asignador a continuación.

4) Construye el contenedor subyacente con el contenido del contenedor cont. Primero, inicializa c con std::move(cont) y compare con comp. Luego ordena c con respecto a comp.

5) Igual que (4), equivale a flat_set(cont);. Véase la nota de uso de asignador a continuación.

6) Igual que (4), equivalente a flat_set(cont, comp);. Véase la nota de uso de asignador a continuación.

7) Construye el contenedor subyacente con el contenido del otro contenedor cont. Inicializa c con std::move(cont) y compare con comp.

8) Igual que (7), equivalente a flat_set(s, cont);. Véase la nota de uso de asignador a continuación.

9) Igual que (7), equivalente a flat_set(s, cont, comp);. Véase la nota de uso de asignador a continuación.

10) Construye un adaptador de contenedor vacío.

11,12) Construye un adaptador de contenedor vacío. Véase la nota de uso de asignador a continuación.

13) Construye el adaptador contenedor con el contenido del rango [first, last), equivalente a insert(first, last);.

14,15) Igual que (13). Véase la nota de uso de asignador a continuación.

16) Construye el adaptador contenedor con el contenido del rango rg. Primero, usa (10) como constructor delegador. Luego inicializa c con el contenido de rg como si fuera por insert_range(std::forward<R>(rg));.

18,19) Igual que (16). Véase la nota de uso de asignador a continuación.

20) Construye el contenedor subyacente con el contenido del rango [primero, último). Inicializa c con c(first, last) y compare con compare(comp).

21,22) Igual que (20). Véase la nota de uso de asignador a continuación.

24,25) Igual que (23). Véase la nota de uso de asignador a continuación.

27,28) Guardar como (26). Véase la nota de uso de asignador a continuación.

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

Nota de uso de 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 que no usan asignador, excepto que c se construye con construcción de uso de asignador. Estas sobrecargas participan en la resolución de sobrecargas solo si std::uses_allocator_v<container_type, Allocator> es true.

Parámetros

cont	-	Un contenedor que se utilizará como fuente para inicializar el contenedor subyacente.
other	-	Otro flat_set que se utilizará como fuente para inicializar los elementos del contenedor subyacente.
alloc	-	Un asignador que se utilizará para todas las asignaciones de memoria del contenedor subyacente.
comp	-	Un objeto función que se utilizará para todas las comparaciones de claves.
first, last	-	El par de iteradores que definen el fuente rango fuente de elementos a copiar
init	-	Una lista de inicializadores para inicializar los elementos del contenedor subyacente.
rg	-	Un rango compatible con contenedor (es decir, un input_range cuyos elementos se pueden convertir a value_type) que se utilizará como fuente para inicializar el contenedor subyacente.
fr	-	Una etiqueta de desambiguación que indica que el miembro contenido debe construirse en rango.
s	-	Una etiqueta de desambiguación que indica que la secuencia de entrada está ordenada con respecto a compare
Requisitos de tipo
-InputIt debe satisfacer los requisitos de IteradorDeEntradaLegado.
-Compare debe satisfacer los requisitos de Comparar.
-Allocator debe satisfacer los requisitos de Asignador.

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 tamaño de cont.

4-6) Lineal en N si cont está ordenado con respecto a compare, de lo contrario 𝓞(N·log(N)), donde N es el valor de cont.size() antes de esta llamada.

7-9) Igual que el constructor de movimiento correspondiente del contenedor envuelto, es decir, constante o lineal en tamaño de cont.

10-12) Constante.

13-15) Lineal en N si el rango de entrada [first, last) está ordenado con respecto a compare, de lo contrario 𝓞(N·log(N)), donde N es el valor de cont.size() antes de esta llamada.

16-19) Lineal en N si el rango de entrada rg está ordenado con respecto a compare, de lo contrario 𝓞(N·log(N)), donde N es el valor de cont.size() antes de esta llamada.

20-22) Lineal en tamaño de [first, last).

23-25) Lineal en N si los elementos de init están ordenados con respecto a compare, de lo contrario 𝓞(N·log(N)), donde N es el valor de cont.size() antes de esta llamada.

26-28) Lineal en tamaño de init.

Excepciones

Las llamadas a Allocator::allocate pueden generar una excepción.

Notas

Después de la construcción por movimiento de un contenedor (la sobrecarga (3,16-19)), las referencias, punteros e iteradores (aparte del iterador al final) a other permanecen válidos, pero se refieren a los elementos que ahora se encuentran en *this. El estándar actual da esta garantía vía la generalización en [container.requirements.general]/12, y una garantía más directa está bajo consideración vía LWG 2321.

Ejemplo

Véase también