std::unordered_set<Key,Hash,KeyEqual,Allocator>:: insert

1,2) Inserta value .

3,4) Inserta value , utilizando hint como sugerencia no vinculante sobre dónde debería comenzar la búsqueda.

5) Inserta elementos del rango [ first , last ) . Si múltiples elementos en el rango tienen claves que son equivalentes, no está especificado qué elemento se inserta (pendiente de LWG2844 ).

6) Inserta elementos desde la lista de inicializadores ilist . Si múltiples elementos en el rango tienen claves que son equivalentes, no está especificado qué elemento se inserta (pendiente de LWG2844 ).

7) Si nh es un node handle vacío, no hace nada. De lo contrario, inserta el elemento poseído por nh en el contenedor, si el contenedor no contiene ya un elemento con una clave equivalente a nh. key ( ) . El comportamiento es indefinido si nh no está vacío y get_allocator ( ) ! = nh. get_allocator ( ) .

8) Si nh es un node handle vacío, no hace nada y retorna el iterador final. De lo contrario, inserta el elemento poseído por nh en el contenedor, si el contenedor aún no contiene un elemento con una clave equivalente a nh. key ( ) , y retorna el iterador que apunta al elemento con clave equivalente a nh. key ( ) (independientemente de si la inserción tuvo éxito o falló). Si la inserción tiene éxito, nh es movido, de lo contrario conserva la propiedad del elemento. hint se utiliza como sugerencia no vinculante sobre dónde debería comenzar la búsqueda. El comportamiento es indefinido si nh no está vacío y get_allocator ( ) ! = nh. get_allocator ( ) .

9) Si * this ya contiene un elemento que se compara transparentemente equivalente a obj , no hace nada. De lo contrario, construye un objeto u de value_type con std:: forward < K > ( obj ) y luego inserta u en * this . Si equal_range ( u ) ! = hash_function ( ) ( obj ) || contains ( u ) es true , el comportamiento es indefinido. El value_type debe ser EmplaceConstructible en unordered_set desde std:: forward < K > ( obj ) . Esta sobrecarga participa en la resolución de sobrecarga solo si Hash y KeyEqual son ambos transparentes . Esto asume que dicho Hash puede ser invocado tanto con el tipo K como con el tipo Key , y que el KeyEqual es transparente, lo que, en conjunto, permite llamar a esta función sin construir una instancia de Key .

10) Si * this ya contiene un elemento que se compara transparentemente equivalente a obj , no hace nada.

En caso contrario, construye un objeto u de tipo value_type con std:: forward < K > ( obj ) y luego inserta u en * this . Template:hint se utiliza como sugerencia no vinculante sobre dónde debería comenzar la búsqueda. Si equal_range ( u ) ! = hash_function ( ) ( obj ) || contains ( u ) es true , el comportamiento es indefinido. El value_type debe ser EmplaceConstructible en unordered_set desde std:: forward < K > ( obj ) . Esta sobrecarga participa en la resolución de sobrecarga solo si:

• std:: is_convertible_v < K && , const_iterator > y std:: is_convertible_v < K && , iterator > son ambos false , y
• Hash :: is_transparent y KeyEqual :: is_transparent son válidos y cada uno denota un tipo. Esto asume que dicho Hash es invocable tanto con el tipo K como con el tipo Key , y que el KeyEqual es transparente,

lo que, en conjunto, permite llamar a esta función sin construir una instancia de Key .

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,4) Un iterador al elemento insertado, o al elemento que impidió la inserción.

5,6) (ninguno)

7) Un objeto de insert_return_type con los miembros inicializados de la siguiente manera:

• Si nh está vacío, inserted es false , position es end ( ) , y node está vacío.
• En caso contrario, si la inserción tuvo lugar, inserted es true , position apunta al elemento insertado, y node está vacío.
• Si la inserción falló, inserted es false , node tiene el valor previo de nh , y position apunta a un elemento con una clave equivalente a nh. key ( ) .

8) Iterador final si nh estaba vacío, iterador que apunta al elemento insertado si la inserción tuvo lugar, e iterador que apunta a un elemento con una clave equivalente a nh. key ( ) si falló.

9) 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.

10) Un iterador al elemento insertado, o al elemento que impidió la inserción.

1-4) Si se lanza una excepción por cualquier operación, la inserción no tiene efecto.

1-4) Caso promedio: O(1) , caso peor O(size()) .

5,6) Caso promedio: O(N) , donde N es el número de elementos a insertar. Caso peor: O(N * size() + N) .

7-10) Caso promedio: O(1) , caso peor O(size()) .

#include <array>
#include <iostream>
#include <unordered_set>
std::ostream& operator<<(std::ostream& os, std::unordered_set<int> const& s)
{
    for (os << '[' << s.size() << "] { "; int i : s)
        os << i << ' ';
    return os << "}\n";
}
int main ()
{
    std::unordered_set<int> nums{2, 3, 4};
    std::cout << "1) Initially: " << nums << std::boolalpha;
    auto p = nums.insert(1); // insert element, overload (1)
    std::cout << "2) '1' was inserted: " << p.second << '\n';
    std::cout << "3) After insertion: " << nums;
    nums.insert(p.first, 0); // insert with hint, overload (3)
    std::cout << "4) After insertion: " << nums;
    std::array<int, 4> a = {10, 11, 12, 13};
    nums.insert(a.begin(), a.end()); // insert range, overload (5)
    std::cout << "5) After insertion: " << nums;
    nums.insert({20, 21, 22, 23}); // insert initializer_list, (6)
    std::cout << "6) After insertion: " << nums;
    std::unordered_set<int> other_nums = {42, 43};
    auto node = other_nums.extract(other_nums.find(42));
    nums.insert(std::move(node)); // insert node, overload (7)
    std::cout << "7) After insertion: " << nums;
    node = other_nums.extract(other_nums.find(43));
    nums.insert(nums.begin(), std::move(node)); // insert node with hint, (8)
    std::cout << "8) After insertion: " << nums;
}

1) Initially: [3] { 4 3 2 }
2) '1' was inserted: true
3) After insertion: [4] { 1 2 3 4 }
4) After insertion: [5] { 0 1 2 3 4 }
5) After insertion: [9] { 13 12 11 10 4 3 2 1 0 }
6) After insertion: [13] { 23 22 13 12 11 10 21 4 20 3 2 1 0 }
7) After insertion: [14] { 42 23 22 13 12 11 10 21 4 20 3 2 1 0 }
8) After insertion: [15] { 43 42 23 22 13 12 11 10 21 4 20 3 2 1 0 }