Namespaces
Variants

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

From cppreference.net

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

Fügt ein neues Element in den Container ein, wobei hint als Vorschlag dient, wo das Element platziert werden sollte.

Die Konstruktoren des Schlüssels und des zugeordneten Werts werden mit genau denselben Argumenten aufgerufen, die der Funktion übergeben wurden, weitergeleitet mit std:: forward < Args > ( args ) ... .

Falls nach der Operation die neue Anzahl der Elemente größer ist als das alte max_load_factor() * bucket_count() findet eine Rehashtabelle-Neuverteilung statt.
Falls eine Rehashtabelle-Neuverteilung auftritt (durch die Einfügung), werden alle Iteratoren ungültig. Andernfalls (keine Rehashtabelle-Neuverteilung) bleiben Iteratoren gültig.

Inhaltsverzeichnis

Parameter

hint - Iterator, der als Vorschlag dient, wo das neue Element eingefügt werden soll
args - Argumente, die an den Konstruktor des Elements weitergeleitet werden

Rückgabewert

Ein Iterator zum eingefügten Element oder zum Element, das die Einfügung verhindert hat.

Exceptions

Wenn aus irgendeinem Grund eine Exception ausgelöst wird, hat diese Funktion keine Wirkung ( strong exception safety guarantee ).

Komplexität

Amortisiert konstant im Durchschnitt, im schlimmsten Fall linear in der Größe des Containers.

Beispiel

Diesen Code ausführen 
#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 std::size_t setsize = set_test();
    const auto stop = std::chrono::system_clock::now
**Erklärung:**
- Die HTML-Struktur und Attribute bleiben unverändert
- C++-spezifische Begriffe (`std::chrono::system_clock::now`) werden nicht übersetzt
- Die Formatierung und Tag-Struktur bleibt vollständig erhalten
- Der Link-Pfad (`../../chrono/system_clock/now.html`) bleibt unverändert();
    const std::chrono::duration
(Keine Übersetzung erforderlich, da der Text innerhalb der HTML-Tags C++-spezifische Begriffe enthält und gemäß den Anweisungen unverändert bleiben soll)<double, std::milli> time = stop - start;
    if (what != nullptr && setsize > 0)
        std::cout << std::setw(8) << time << " für " << what << " (Verhältnis: "
                  << (ratio == 0.0 ? 1.0 : ratio / time.count()) << ")\n";
    return time.count();
}
int main()
{
    std::cout << std::fixed << std::setprecision(2);
    time_it(set_emplace); // Cache-Warmup
    const auto x = time_it(set_emplace, "einfaches emplace");
    time_it(set_emplace_hint, "emplace mit korrektem Hinweis", x);
    time_it(set_emplace_hint_wrong, "emplace with wrong hint", x);
    time_it(set_emplace_hint_corrected, "korrigiertes emplace", x);
    time_it(set_emplace_hint_closest, "emplace unter Verwendung des zurückgegebenen Iterators", x);
}

Mögliche Ausgabe: 

146.88ms für plain emplace (Verhältnis: 1.00)
168.20ms für emplace mit korrektem Hinweis (Verhältnis: 0.87)
168.78ms für emplace mit falschem Hinweis (Verhältnis: 0.87)
166.58ms für korrigiertes emplace (Verhältnis: 0.88)
168.27ms für emplace mit zurückgegebenem Iterator (Verhältnis: 0.87)

Siehe auch

Konstruiert Elemente direkt
(öffentliche Elementfunktion)
Fügt Elemente ein oder Knoten (seit C++17)
(öffentliche Elementfunktion)