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

Fügt ein neues Element in den Container ein, das direkt mit den gegebenen args erstellt wird.

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 ) ... .

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

Falls nach dem Vorgang die neue Anzahl der Elemente größer ist als das alte max_load_factor() * bucket_count() findet eine Rehashtabelle statt.
Falls Rehashing auftritt (aufgrund der Einfügung), werden alle Iteratoren ungültig. Andernfalls (kein Rehashing) bleiben Iteratoren gültig.

Parameter

Rückgabewert

Ein Iterator auf das eingefügte Element.

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_multimap<std::string, std::string> m;
    // verwendet Pairs Move-Konstruktor
    m.emplace(std::make_pair(std::string("a"), std::string("a")));
    // verwendet Pairs konvertierenden Move-Konstruktor
    m.emplace(std::make_pair("b", "abcd"));
    // verwendet Pairs Template-Konstruktor
    m.emplace("d", "ddd");
    // emplace mit doppeltem Schlüssel
    m.emplace("d", "DDD");
    // verwendet Pairs Piecewise-Konstruktor
    m.emplace(std::piecewise_construct,
              std::forward_as_tuple("c"),
              std::forward_as_tuple(10, 'c'));
    for (const auto& p : m)
        std::cout << p.first << " => " << p.second << '\n';
}

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

Siehe auch