Namespaces
Variants

std::set<Key,Compare,Allocator>:: emplace_hint

From cppreference.net

C++
Containers library
std::set
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
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 so nah wie möglich an die Position direkt vor hint in den Container ein.

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

Keine Iteratoren oder Referenzen werden ungültig.

Inhaltsverzeichnis

Parameter

Hinweis - Iterator auf die Position, vor der das neue Element eingefügt wird
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.

Ausnahmen

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

Komplexität

Logarithmisch in der Größe des Containers im Allgemeinen, aber amortisiert konstant, wenn das neue Element direkt vor hint eingefügt wird.

Beispiel

Diesen Code ausführen 
#include <chrono>
#include <cstddef>
#include <functional>
#include <iomanip>
#include <iostream>
#include <set>
const int n_operations = 1005000;
std::size_t set_emplace()
{
    std::set<int> set;
    for (int i = 0; i < n_operations; ++i)
        set.emplace(i);
    return set.size();
}
std::size_t set_emplace_hint()
{
    std::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::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::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::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<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 mit falschem Hinweis", 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: 

392.25ms für einfaches emplace (Verhältnis: 1.00)
 97.15ms für emplace mit korrektem Hinweis (Verhältnis: 4.04)
387.52ms für emplace mit falschem Hinweis (Verhältnis: 1.01)
 84.80ms für korrigiertes emplace (Verhältnis: 4.63)
 83.67ms für emplace mit zurückgegebenem Iterator (Verhältnis: 4.69)

Siehe auch

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