Namespaces
Variants

std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>:: emplace_hint

From cppreference.net

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

Fügt ein neues Element so nah wie möglich an die Position direkt vor hint in den Container ein.

Der Konstruktor von value_type (d.h. std:: pair < const Key, T > ) wird mit exakt denselben Argumenten aufgerufen, die der Funktion übergeben wurden, weitergeleitet mit std:: forward < Args > ( args ) ... .

Informationen zur Iterator-Invalidierung sind kopiert von hier

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.

Exceptions

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

Komplexität

Dieser Abschnitt ist unvollständig

Beispiel

Diesen Code ausführen 
#include <chrono>
#include <cstddef>
#include <functional>
#include <iomanip>
#include <iostream>
#include <flat_map>
const int n_operations = 100'500'0;
std::size_t map_emplace()
{
    std::flat_map<int, char> map;
    for (int i = 0; i < n_operations; ++i)
        map.emplace(i, 'a');
    return map.size();
}
std::size_t map_emplace_hint()
{
    std::flat_map<int, char> map;
    auto it = map.begin();
    for (int i = 0; i < n_operations; ++i)
    {
        map.emplace_hint(it, i, 'b');
        it = map.end();
    }
    return map.size();
}
std::size_t map_emplace_hint_wrong()
{
    std::flat_map<int, char> map;
    auto it = map.begin();
    for (int i = n_operations; i > 0; --i)
    {
        map.emplace_hint(it, i, 'c');
        it = map.end();
    }
    return map.size();
}
std::size_t map_emplace_hint_corrected()
{
    std::flat_map<int, char> map;
    auto it = map.begin();
    for (int i = n_operations; i > 0; --i)
    {
        map.emplace_hint(it, i, 'd');
        it = map.begin();
    }
    return map.size();
}
std::size_t map_emplace_hint_closest()
{
    std::flat_map<int, char> map;
    auto it = map.begin();
    for (int i = 0; i < n_operations; ++i)
        it = map.emplace_hint(it, i, 'e');
    return map.size();
}
double time_it(std::function<std::size_t()> map_test,
               std::string what = "", double ratio = 0.0)
{
    const auto start = std::chrono::system_clock::now();
    const std::size_t map_size = map_test();
    const auto stop = std::chrono::system_clock::now();
    std::chrono::duration<double, std::milli> time = stop - start;
    if (what.size() && map_size)
        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(map_emplace); // Cache-Warmup
    const auto x = time_it(map_emplace, "einfaches emplace");
    time_it(map_emplace_hint, "emplace mit korrektem Hinweis", x);
    time_it(map_emplace_hint_wrong, "emplace mit falschem Hinweis", x);
    time_it(map_emplace_hint_corrected, "korrigiertes emplace", x);
    time_it(map_emplace_hint_closest, "emplace mit zurückgegebenem Iterator", x);
}

Mögliche Ausgabe: 

...TODO...

Siehe auch

Konstruiert Elemente direkt
(öffentliche Elementfunktion)
Fügt Elemente ein
(öffentliche Elementfunktion)