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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::unordered_multimap

Membertypen
Memberfunktionen
unordered_multimap::unordered_multimap unordered_multimap::~unordered_multimap    unordered_multimap::operator= unordered_multimap::get_allocator Iteratoren unordered_multimap::beginunordered_multimap::cbegin unordered_multimap::endunordered_multimap::cend Kapazität unordered_multimap::size unordered_multimap::max_size unordered_multimap::empty Modifizierer unordered_multimap::clear unordered_multimap::insert unordered_multimap::insert_range (C++23) unordered_multimap::emplace unordered_multimap::emplace_hint unordered_multimap::erase unordered_multimap::swap unordered_multimap::extract (C++17) unordered_multimap::merge (C++17)	Suche unordered_multimap::count unordered_multimap::find unordered_multimap::contains (C++20) unordered_multimap::equal_range Bucket-Schnittstelle unordered_multimap::begin(size_type)unordered_multimap::cbegin(size_type) unordered_multimap::end(size_type)unordered_multimap::cend(size_type) unordered_multimap::bucket_count unordered_multimap::max_bucket_count unordered_multimap::bucket_size unordered_multimap::bucket Hash-Politik unordered_multimap::load_factor unordered_multimap::max_load_factor unordered_multimap::rehash unordered_multimap::reserve Observer unordered_multimap::hash_function unordered_multimap::key_eq
Nicht-Member-Funktionen
std::swap(std::unordered_multimap) erase_if(std::unordered_multimap) (C++20)	operator==operator!= (bis C++20)
Deduction guides (C++17)

 

template< class... Args > iterator emplace( Args&&... args );		(seit C++11)

Fügt ein neues Element in den Container ein, das mit den gegebenen args vor Ort konstruiert 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 über std::forward<Args>(args)....

Eine sorgfältige Verwendung von emplace ermöglicht die Konstruktion des neuen Elements unter Vermeidung unnötiger Kopier- oder Verschiebungsoperationen.

Wenn nach der Operation die neue Anzahl der Elemente größer ist als max_load_factor() * bucket_count(), findet ein Re-Hashing statt.
Wenn Rehashing stattfindet (aufgrund der Einfügung), werden alle Iteratoren ungültig. Andernfalls (kein Rehashing) werden Iteratoren nicht ungültig.

Parameter

args

-

Argumente, die an den Konstruktor des Elements weitergeleitet werden

Rückgabewert

Ein Iterator zu dem eingefügten Element.

Ausnahmen

Wenn aus irgendeinem Grund eine Ausnahme ausgelöst wird, hat diese Funktion keine Auswirkungen (starkes Ausnahmesicherheitsgarantie).

Komplexität

Im Durchschnitt amortisiert konstant, im schlimmsten Fall linear zur Größe des Containers.

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <string>
#include <utility>
#include <unordered_map>
 
int main()
{
    std::unordered_multimap<std::string, std::string> m;
 
    // uses pair's move constructor
    m.emplace(std::make_pair(std::string("a"), std::string("a")));
 
    // uses pair's converting move constructor
    m.emplace(std::make_pair("b", "abcd"));
 
    // uses pair's template constructor
    m.emplace("d", "ddd");
 
    // emplace with duplicate key 
    m.emplace("d", "DDD");
 
    // uses pair's piecewise constructor
    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';
}

Mögliche Ausgabe

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

Siehe auch

emplace_hint	konstruiert Elemente "in place" unter Verwendung eines Hinweises (public member function)
try_emplace	fügt "in place" ein, wenn der Schlüssel nicht existiert, tut nichts, wenn der Schlüssel existiert (public member function)
insert	fügt Elemente ein oder Knoten(seit C++17) (public member function)