std:: flat_set

Definido en el encabezado <flat_set>
template < class Key, class Compare = std:: less < Key > , class KeyContainer = std:: vector < Key > > class flat_set ;		(desde C++23)

El flat set es un container adaptor que proporciona la funcionalidad de un contenedor asociativo que almacena un conjunto ordenado de objetos únicos de tipo Key . La ordenación se realiza utilizando la función de comparación de claves Compare .

La plantilla de clase flat_set actúa como un contenedor wrapper para el contenedor subyacente ordenado que se pasa como objeto de tipo KeyContainer .

En todas partes donde la biblioteca estándar utiliza los Compare requisitos, la unicidad se determina utilizando la relación de equivalencia. Informalmente, dos objetos a y b se consideran equivalentes si ninguno se compara menor que el otro: ! comp ( a, b ) && ! comp ( b, a ) .

std::flat_set cumple con los requisitos de Container , ReversibleContainer , requisitos opcionales de contenedor , y todos los requisitos de AssociativeContainer (incluyendo complejidad de búsqueda logarítmica), excepto que:

• los requisitos relacionados con nodos no son aplicables,
• los requisitos de invalidación de iteradores difieren,
• la complejidad de las operaciones de inserción y borrado es lineal.

Un flat set admite la mayoría de las operaciones de AssociativeContainer que utilizan claves únicas.

Todas las funciones miembro de std::flat_set son constexpr : es posible crear y utilizar objetos std::flat_set en la evaluación de una expresión constante. Sin embargo, los objetos std::flat_set generalmente no pueden ser constexpr , porque cualquier almacenamiento asignado dinámicamente debe liberarse en la misma evaluación de la expresión constante.

(desde C++26)

Contenidos 1 Invalidación de iteradores 2 Parámetros de plantilla 3 Tipos miembro 4 Objetos miembro 5 Funciones miembro 5.1 Iteradores 5.2 Capacidad 5.3 Modificadores 5.4 Búsqueda 5.5 Observadores 6 Funciones no miembro 7 Clases auxiliares 8 Etiquetas 9 Guías de deducción 10 Notas 11 Ejemplo 12 Véase también

Invalidación de iteradores

Esta sección está incompleta

Parámetros de plantilla

Key	-	El tipo de los elementos almacenados. El programa está mal formado si Key no es del mismo tipo que KeyContainer::value_type .
Compare	-	Un tipo Compare que proporciona un ordenamiento débil estricto.
KeyContainer	-	El tipo del SequenceContainer subyacente para almacenar los elementos. Los iteradores de dicho contenedor deben satisfacer LegacyRandomAccessIterator o modelar random_access_iterator . Los contenedores estándar std::vector y std::deque cumplen con estos requisitos.

Tipos de miembros

Tipo	Definición
container_type	Key Container
key_type	Key
value_type	Key
key_compare	Compare
value_compare	Compare
reference	value_type &
const_reference	const value_type &
size_type	typename KeyContainer :: size_type
difference_type	typename KeyContainer :: difference_type
iterator	definido por la implementación LegacyRandomAccessIterator , ConstexprIterator (desde C++26) y random_access_iterator a value_type
const_iterator	definido por la implementación LegacyRandomAccessIterator , ConstexprIterator (desde C++26) y random_access_iterator a const value_type
reverse_iterator	std:: reverse_iterator < iterator >
const_reverse_iterator	std:: reverse_iterator < const_iterator >

Objetos miembro

Miembro	Descripción
container_type c (privado)	el contenedor adaptado ( objeto miembro solo para exposición* )
key_compare compare (privado)	el objeto función de comparación ( objeto miembro solo para exposición* )

Funciones miembro

(constructor)	construye el flat_set (función miembro pública)
(destructor) (implicitly declared)	destruye cada elemento del adaptador de contenedor (función miembro pública)
operator=	asigna valores al adaptador de contenedor (función miembro pública)
Iteradores
begin cbegin	devuelve un iterador al inicio (función miembro pública)
end cend	devuelve un iterador al final (función miembro pública)
rbegin crbegin	devuelve un iterador inverso al principio (función miembro pública)
rend crend	devuelve un iterador inverso al final (función miembro pública)
Capacidad
empty	comprueba si el adaptador de contenedor está vacío (función miembro pública)
size	devuelve el número de elementos (función miembro pública)
max_size	devuelve el número máximo posible de elementos (función miembro pública)
Modificadores
emplace	construye el elemento in situ (función miembro pública)
emplace_hint	construye elementos in-situ usando una pista (función miembro pública)
insert	inserta elementos (función miembro pública)
insert_range	inserta un rango de elementos (función miembro pública)
extract	extrae el contenedor subyacente (función miembro pública)
replace	reemplaza el contenedor subyacente (función miembro pública)
erase	elimina elementos (función miembro pública)
swap	intercambia los contenidos (función miembro pública)
clear	borra el contenido (función miembro pública)
Búsqueda
find	encuentra elemento con clave específica (función miembro pública)
count	devuelve el número de elementos que coinciden con una clave específica (función miembro pública)
contains	comprueba si el contenedor contiene un elemento con una clave específica (función miembro pública)
lower_bound	devuelve un iterador al primer elemento no menor que la clave dada (función miembro pública)
upper_bound	devuelve un iterador al primer elemento mayor que la clave dada (función miembro pública)
equal_range	devuelve el rango de elementos que coinciden con una clave específica (función miembro pública)
Observadores
key_comp	devuelve la función que compara claves (función miembro pública)
value_comp	devuelve la función que compara claves en objetos de tipo value_type (función miembro pública)

Funciones no miembro

operator== operator<=> (C++23)	compara lexicográficamente los valores de dos flat_set s (plantilla de función)
std::swap (std::flat_set) (C++23)	especializa el algoritmo std::swap (plantilla de función)
erase_if (std::flat_set) (C++23)	elimina todos los elementos que cumplen criterios específicos (plantilla de función)

Clases auxiliares

std::uses_allocator <std::flat_set> (C++23)

especializa el rasgo de tipo std::uses_allocator (especialización de plantilla de clase)

Etiquetas

sorted_unique sorted_unique_t (C++23)

indica que los elementos de un rango están ordenados y son únicos (etiqueta)

Guías de deducción

Notas

Los tipos miembro iterator y const_iterator pueden ser alias del mismo tipo. Esto significa que definir un par de sobrecargas de función usando los dos tipos como tipos de parámetro puede violar la One Definition Rule . Dado que iterator es convertible a const_iterator , una única función con un const_iterator como tipo de parámetro funcionará en su lugar.

Algunas ventajas del flat set sobre otros adaptadores de contenedor estándar son:

• Búsqueda potencialmente más rápida (aunque las operaciones de búsqueda tienen complejidad logarítmica).
• Iteración mucho más rápida: random access iterators en lugar de bidirectional iterators .
• Menor consumo de memoria para objetos pequeños (y para objetos grandes si KeyContainer :: shrink_to_fit ( ) está disponible).
• Mejor rendimiento de caché (dependiendo de KeyContainer , las claves se almacenan en un bloque(s) contiguo(s) de memoria).

Algunas desventajas del conjunto plano son:

• Iteradores no estables (los iteradores se invalidan al insertar y eliminar elementos).
• No se pueden almacenar valores de tipos no copiables y no movibles.
• Seguridad de excepciones más débil (los constructores de copia/movimiento pueden lanzar excepciones al desplazar valores en eliminaciones e inserciones).
• Inserción y eliminación más lentas (es decir, lineales), especialmente para tipos no movibles.

Macro de prueba de características	Valor	Estándar	Característica
__cpp_lib_flat_set	202207L	(C++23)	std::flat_set y std::flat_multiset
__cpp_lib_constexpr_flat_set	202502L	(C++26)	constexpr std::flat_set

Ejemplo

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

Véase también

flat_multiset (C++23)	adapta un contenedor para proporcionar una colección de claves, ordenadas por claves (plantilla de clase)
set	colección de claves únicas, ordenadas por claves (plantilla de clase)
unordered_set (C++11)	colección de claves únicas, distribuidas mediante hash por claves (plantilla de clase)