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

1,2) Insère value .

3,4) Insère value , en utilisant hint comme suggestion non-contraignante pour indiquer où la recherche devrait commencer.

5) Insère les éléments de la plage [ first , last ) . Si plusieurs éléments dans la plage ont des clés qui sont équivalentes, il n'est pas spécifié quel élément est inséré (en attente de LWG2844 ).

6) Insère les éléments de la liste d'initialisation ilist . Si plusieurs éléments dans la plage ont des clés qui sont équivalentes lors de la comparaison, il n'est pas spécifié quel élément est inséré (en attente de LWG2844 ).

7) Si nh est un node handle vide, ne fait rien. Sinon, insère l'élément possédé par nh dans le conteneur, si le conteneur ne contient pas déjà un élément avec une clé équivalente à nh. key ( ) . Le comportement est indéfini si nh n'est pas vide et get_allocator ( ) ! = nh. get_allocator ( ) .

8) Si nh est un node handle vide, ne fait rien et retourne l'itérateur de fin. Sinon, insère l'élément possédé par nh dans le conteneur, si le conteneur ne contient pas déjà un élément avec une clé équivalente à nh. key ( ) , et retourne l'itérateur pointant vers l'élément avec la clé équivalente à nh. key ( ) (que l'insertion ait réussi ou échoué). Si l'insertion réussit, nh est déplacé, sinon il conserve la possession de l'élément. hint est utilisé comme suggestion non contraignante pour indiquer où la recherche devrait commencer. Le comportement est indéfini si nh n'est pas vide et get_allocator ( ) ! = nh. get_allocator ( ) .

9) Si * this contient déjà un élément qui compare de manière transparente équivalent à obj , ne fait rien. Sinon, construit un objet u de value_type avec std:: forward < K > ( obj ) et insère ensuite u dans * this . Si equal_range ( u ) ! = hash_function ( ) ( obj ) || contains ( u ) est true , le comportement est indéfini. Le value_type doit être EmplaceConstructible dans unordered_set à partir de std:: forward < K > ( obj ) . Cette surcharge participe à la résolution de surcharge seulement si Hash et KeyEqual sont tous deux transparents . Cela suppose qu'un tel Hash peut être appelé avec à la fois le type K et le type Key , et que le KeyEqual est transparent, ce qui, ensemble, permet d'appeler cette fonction sans construire une instance de Key .

10) Si * this contient déjà un élément qui se compare de manière transparente équivalent à obj , ne fait rien.

Sinon, construit un objet u de type value_type avec std:: forward < K > ( obj ) puis insère u dans * this . Template:hint est utilisé comme suggestion non contraignante pour l'emplacement où la recherche devrait commencer. Si equal_range ( u ) ! = hash_function ( ) ( obj ) || contains ( u ) est true , le comportement est indéfini. Le value_type doit être EmplaceConstructible dans unordered_set à partir de std:: forward < K > ( obj ) . Cette surcharge participe à la résolution de surcharge seulement si :

• std:: is_convertible_v < K && , const_iterator > et std:: is_convertible_v < K && , iterator > sont tous deux false , et
• Hash :: is_transparent et KeyEqual :: is_transparent sont valides et chacun désigne un type. Cela suppose qu'un tel Hash peut être appelé avec à la fois le type K et le type Key , et que le KeyEqual est transparent,

ce qui, ensemble, permet d'appeler cette fonction sans construire une instance de Key .

1,2) Une paire constituée d'un itérateur vers l'élément inséré (ou vers l'élément qui a empêché l'insertion) et une valeur bool définie à true si et seulement si l'insertion a eu lieu.

3,4) Un itérateur vers l'élément inséré, ou vers l'élément qui a empêché l'insertion.

5,6) (aucun)

7) Un objet de insert_return_type avec les membres initialisés comme suit :

• Si nh est vide, inserted est false , position est end ( ) , et node est vide.
• Sinon, si l'insertion a eu lieu, inserted est true , position pointe vers l'élément inséré, et node est vide.
• Si l'insertion a échoué, inserted est false , node a la valeur précédente de nh , et position pointe vers un élément avec une clé équivalente à nh. key ( ) .

8) Itérateur de fin si nh était vide, itérateur pointant vers l'élément inséré si l'insertion a eu lieu, et itérateur pointant vers un élément avec une clé équivalente à nh. key ( ) si elle a échoué.

9) Une paire constituée d'un itérateur vers l'élément inséré (ou vers l'élément qui a empêché l'insertion) et une valeur bool définie à true si et seulement si l'insertion a eu lieu.

10) Un itérateur vers l'élément inséré, ou vers l'élément qui a empêché l'insertion.

1-4) Si une exception est levée par une opération quelconque, l'insertion n'a aucun effet.

1-4) Cas moyen : O(1) , cas le pire O(size()) .

5,6) Cas moyen : O(N) , où N est le nombre d'éléments à insérer. Cas le plus défavorable : O(N * size() + N) .

7-10) Cas moyen : O(1) , cas le plus défavorable 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 }