Namespaces
Variants
Actions

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

From cppreference.com

[edit template]
 
C++
 
Containers library
 
std::unordered_set
Member types
Member functions
Non-member functions
(until C++20)
Deduction guides (C++17)
 
template< class... Args >
iterator emplace_hint( const_iterator hint, Args&&... args );
 (since C++11)
(constexpr since C++26)

Inserts a new element into the container, using hint as a suggestion where the element should go.

The constructors of the key and mapped value are called with exactly the same arguments as supplied to the function, forwarded with std::forward<Args>(args)....

If after the operation the new number of elements is greater than old max_load_factor() * bucket_count() a rehashing takes place.
If rehashing occurs (due to the insertion), all iterators are invalidated. Otherwise (no rehashing), iterators are not invalidated.

Contents

[edit] Parameters

hint - iterator, used as a suggestion as to where to insert the new element
args - arguments to forward to the constructor of the element

[edit] Return value

An iterator to the inserted element, or to the element that prevented the insertion.

[edit] Exceptions

If an exception is thrown for any reason, this function has no effect (strong exception safety guarantee).

[edit] Complexity

Amortized constant on average, worst case linear in the size of the container.

[edit] Example

Run this code
#include <chrono>
#include <cstddef>
#include <functional>
#include <iomanip>
#include <iostream>
#include <unordered_set>
 
const int n_operations = 1005000;
 
std::size_t set_emplace()
{
    std::unordered_set<int> set;
    for (int i = 0; i < n_operations; ++i)
        set.emplace(i);
    return set.size();
}
 
std::size_t set_emplace_hint()
{
    std::unordered_set<int> set;
    auto it = set.begin();
    for (int i = 0; i < n_operations; ++i)
    {
        set.emplace_hint(it, i);
        it = set.end();
    }
    return set.size();
}
 
std::size_t set_emplace_hint_wrong()
{
    std::unordered_set<int> set;
    auto it = set.begin();
    for (int i = n_operations; i > 0; --i)
    {
        set.emplace_hint(it, i);
        it = set.end();
    }
    return set.size();
}
 
std::size_t set_emplace_hint_corrected()
{
    std::unordered_set<int> set;
    auto it = set.begin();
    for (int i = n_operations; i > 0; --i)
    {
        set.emplace_hint(it, i);
        it = set.begin();
    }
    return set.size();
}
 
std::size_t set_emplace_hint_closest()
{
    std::unordered_set<int> set;
    auto it = set.begin();
    for (int i = 0; i < n_operations; ++i)
        it = set.emplace_hint(it, i);
    return set.size();
}
 
double time_it(std::function<std::size_t()> set_test,
               const char* what = nullptr,
               double ratio = 0.0)
{
    const auto start = std::chrono::system_clock::now();
    const