std::unordered_map<Key,T,Hash,KeyEqual,Allocator>:: emplace

Fügt ein neues Element in den Container ein, das vor Ort mit den gegebenen args konstruiert wird, falls kein Element mit dem Schlüssel im Container vorhanden ist.

Der Konstruktor des neuen Elements (d.h. std:: pair < const Key, T > ) wird mit exakt denselben Argumenten aufgerufen, die an emplace übergeben wurden, weitergeleitet via std:: forward < Args > ( args ) ... . Das Element kann selbst dann konstruiert werden, wenn bereits ein Element mit demselben Schlüssel im Container existiert. In diesem Fall wird das neu konstruierte Element sofort zerstört (siehe try_emplace() , falls dieses Verhalten unerwünscht ist).

Wenn value_type nicht EmplaceConstructible in unordered_map aus args ist, ist das Verhalten undefiniert.

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

Parameter

Rückgabewert

Ein Paar bestehend aus einem Iterator zum eingefügten Element (oder zum Element, das die Einfügung verhindert hat) und einem bool -Wert, der auf true gesetzt ist, genau dann wenn die Einfügung stattgefunden 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.

Hinweise

Sorgfältige Verwendung von emplace ermöglicht die Konstruktion des neuen Elements, während unnötige Kopier- oder Verschiebeoperationen vermieden werden.

Beispiel

#include <iostream>
#include <string>
#include <utility>
#include <unordered_map>
int main()
{
    std::unordered_map<std::string, std::string> m;
    // verwendet pair's Move-Konstruktor
    m.emplace(std::make_pair(std::string("a"), std::string("a")));
    // verwendet pair's konvertierenden Move-Konstruktor
    m.emplace(std::make_pair("b", "abcd"));
    // verwendet pair's Template-Konstruktor
    m.emplace("d", "ddd");
    // emplace mit doppeltem Schlüssel hat keine Wirkung
    m.emplace("d", "DDD");
    // verwendet pair's piecewise-Konstruktor
    m.emplace(std::piecewise_construct,
              std::forward_as_tuple("c"),
              std::forward_as_tuple(10, 'c'));
    // eine Alternative ist: m.try_emplace("c", 10, 'c');
    for (const auto& p : m)
        std::cout << p.first << " => " << p.second << '\n';
}

a => a
b => abcd
c => cccccccccc
d => ddd

Siehe auch