Namespaces
Variants

std::flat_set<Key,Compare,KeyContainer>:: insert

From cppreference.net
C++
Containers library
std::flat_set
Member types
Member functions
Helper classes
Tags
Deduction guides
std:: pair < iterator, bool > insert ( const value_type & value ) ;
(1) (desde C++23)
std:: pair < iterator, bool > insert ( value_type && value ) ;
(2) (desde C++23)
iterator insert ( const_iterator pos, const value_type & value ) ;
(3) (desde C++23)
iterator insert ( const_iterator pos, value_type && value ) ;
(4) (desde C++23)
template < class K >
iterator insert ( const_iterator pos, K && x ) ;
(5) (desde C++23)
template < class InputIt >
void insert ( InputIt first, InputIt last ) ;
(6) (desde C++23)
template < class K >
std:: pair < iterator, bool > insert ( K && x ) ;
(7) (desde C++23)
template < class InputIt >
void insert ( std:: sorted_unique_t , InputIt first, InputIt last ) ;
(8) (desde C++23)
void insert ( std:: initializer_list < key_type > ilist ) ;
(9) (desde C++23)
void insert ( std:: sorted_unique_t s, std:: initializer_list < key_type > ilist ) ;
(10) (desde C++23)

Inserta elemento(s) en el contenedor, si el contenedor no contiene ya un elemento con una clave equivalente.

1) Inserta value . Equivalente a return emplace ( value ) ; .
2) Inserta value . Equivalente a return emplace ( std :: move ( value ) ) ; .
3) Inserta value en la posición más cercana posible a la posición inmediatamente anterior a pos . Equivalente a return emplace_hint ( pos, value ) ; .
4) Inserta value en la posición más cercana posible a la posición inmediatamente anterior a pos . Equivalente a return emplace_hint ( pos, std :: move ( value ) ) ; .
5,7) Si * this ya contiene un elemento que se compara de manera transparente equivalente a x , no hace nada. De lo contrario, inserta un nuevo elemento como si fuera mediante:
  • (5) emplace ( pos, std:: forward < K > ( x ) ) (en la posición tan cercana como sea posible a la posición inmediatamente anterior a pos );
  • (7) emplace ( std:: forward < K > ( x ) ) .
La conversión de x a key_type debe construir un objeto u , para el cual find ( k ) == find ( u ) sea true . De lo contrario, el comportamiento es indefinido.
Estas sobrecargas participan en la resolución de sobrecarga solo si
  • El identificador calificado Compare::is_transparent es válido y denota un tipo, y
  • std:: is_constructible_v < value_type, K > es true ,
lo que en conjunto permite llamar a esta función sin construir una instancia de Key .
6) Equivalente a la secuencia de operaciones:
  1. Inserta elementos del rango [ first , last ) como si fuera mediante c. insert ( c. end ( ) , first, last ) ; .
  2. Ordena el rango de elementos recién insertados con respecto a compare .
  3. Combina el rango ordenado resultante y el rango ordenado de elementos preexistentes en un único rango ordenado. (Nota: la operación de combinación puede asignar memoria).
  4. Borra todos excepto el primer elemento de cada grupo de elementos equivalentes consecutivos.
Si múltiples elementos en el rango tienen claves que son equivalentes en la comparación, no está especificado qué elemento se inserta (pendiente de LWG2844 ).
8) Inserta elementos del rango [ first , last ) . Equivalente a insert ( first, last ) ; .
Si múltiples elementos en el rango tienen claves que son equivalentes al comparar, no está especificado qué elemento se inserta (pendiente de LWG2844 ).
9) Inserta elementos desde la lista de inicialización ilist . Equivalente a insert ( ilist. begin ( ) , ilist. end ( ) ) ; .
Si múltiples elementos en el rango tienen claves que son equivalentes en la comparación, no está especificado qué elemento se inserta (pendiente de LWG2844 ).
10) Inserta elementos desde la lista de inicialización ilist . Equivalente a insert ( s, ilist. begin ( ) , ilist. end ( ) ) ; .
Si múltiples elementos en el rango tienen claves que son equivalentes en la comparación, no está especificado qué elemento se inserta (pendiente de LWG2844 ).
La información sobre la invalidación de iteradores está copiada de aquí

Contenidos

Parámetros

pos - iterador a la posición antes de la cual se insertará el nuevo elemento
value - valor del elemento a insertar
first, last - el par de iteradores que define el rango fuente de elementos a insertar
ilist - lista de inicializadores de la cual insertar los valores
x - un valor de cualquier tipo que pueda compararse transparentemente con una clave
s - una etiqueta de desambiguación que indica que la secuencia de entrada está ordenada (con respecto a compare ) y contiene solo elementos únicos
Requisitos de tipo
-
InputIt debe cumplir con los requisitos de LegacyInputIterator .

Valor de retorno

1,2) Un par que consiste en un iterador al elemento insertado (o al elemento que impidió la inserción) y un valor bool establecido en true si y solo si la inserción tuvo lugar.
3-5) Un iterador al elemento insertado, o al elemento que impidió la inserción.
6) (ninguno)
7) Un par que consiste en un iterador al elemento insertado (o al elemento que impidió la inserción) y un valor bool establecido en true si y solo si la inserción tuvo lugar.
8-10) (ninguno)

Excepciones

1-5,7) Si se lanza una excepción por cualquier operación, la inserción no tiene efecto.
Esta sección está incompleta
Razón: casos 6,8-10

Complejidad

1,2) Logarítmico en size() , más el costo de inserción en c .
3-5) Amortizado constante si la inserción ocurre en la posición justo antes de pos , logarítmico en size() en caso contrario. Más el costo de inserción en c .
6) N + M·log ( M ) , donde N es el size() antes de la operación y M es std:: distance ( first, last ) .
7) Logarítmico en size() , más el costo de inserción en c .
8) Lineal en N , donde N es size() después de la operación.
9) N + M·log ( M ) , donde N es el size() antes de la operación y M es ilist. size ( ) .
10) Lineal en N , donde N es size() después de la operación.

Notas

La inserción con sugerencia ( 3-5 ) no retorna un booleano para ser compatible en firma con la inserción posicional en contenedores secuenciales, como std::vector::insert . Esto permite crear insertores genéricos como std::inserter . Una forma de verificar el éxito de una inserción con sugerencia es comparar size() antes y después.

Ejemplo

Ejecutar este código 
#include <cassert>
#include <flat_set>
#include <iostream>
int main()
{
    std::flat_set<int> set;
    auto result_1 = set.insert(3);
    assert(result_1.first != set.end()); // es un iterador válido
    assert(*result_1.first == 3);
    if (result_1.second)
        std::cout << "insert done\n";
    auto result_2 = set.insert(3);
    assert(result_2.first == result_1.first); // el mismo iterador
    assert(*result_2.first == 3);
    if (!result_2.second)
        std::cout << "no insertion\n";
}

Salida: 

insert done
no insertion

Véase también

construye elemento in-situ
(función miembro pública)
construye elementos in-situ usando una pista
(función miembro pública)
crea un std::insert_iterator del tipo inferido del argumento
(plantilla de función)