std::unordered_map<Key,T,Hash,KeyEqual,Allocator>::try_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_map

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

 

template< class... Args > std::pair<iterator, bool> try_emplace( const Key& k, Args&&... args );	(1)	(seit C++17)
template< class... Args > std::pair<iterator, bool> try_emplace( Key&& k, Args&&... args );	(2)	(seit C++17)
template< class K, class... Args > std::pair<iterator, bool> try_emplace( K&& k, Args&&... args );	(3)	(seit C++26)
template< class... Args > iterator try_emplace( const_iterator hint, const Key& k, Args&&... args );	(4)	(seit C++17)
template< class... Args > iterator try_emplace( const_iterator hint, Key&& k, Args&&... args );	(5)	(seit C++17)
template< class K, class... Args > iterator try_emplace( const_iterator hint, K&& k, Args&&... args );	(6)	(seit C++26)

Wenn ein Schlüssel vorhanden ist, der zu k äquivalent ist, wird nichts unternommen. Andernfalls wird ein neues Element in den Container eingefügt, mit dem Schlüssel k und dem Wert, der mit args konstruiert wurde. In diesem Fall

1) Verhält sich wie emplace, außer dass das Element konstruiert wird als
value_type(std::piecewise_construct,

           std::forward_as_tuple(k),

           std::forward_as_tuple(std::forward<Args>(args)...))

2) Verhält sich wie emplace, außer dass das Element konstruiert wird als
value_type(std::piecewise_construct,

           std::forward_as_tuple(std::move(k)),

           std::forward_as_tuple(std::forward<Args>(args)...))

3) Verhält sich wie emplace, außer dass das Element konstruiert wird als
value_type(std::piecewise_construct,

           std::forward_as_tuple(std::forward<K>(k)),

           std::forward_as_tuple(std::forward<Args>(args)...))

4) Verhält sich wie emplace_hint, außer dass das Element konstruiert wird als
value_type(std::piecewise_construct,

           std::forward_as_tuple(k),

           std::forward_as_tuple(std::forward<Args>(args)...))

5) Verhält sich wie emplace_hint, außer dass das Element konstruiert wird als
value_type(std::piecewise_construct,

           std::forward_as_tuple(std::move(k)),

           std::forward_as_tuple(std::forward<Args>(args)...))

6) Verhält sich wie emplace_hint, außer dass das Element konstruiert wird als
value_type(std::piecewise_construct,

           std::forward_as_tuple(std::forward<K>(k)),

           std::forward_as_tuple(std::forward<Args>(args)...))

1-6) Wenn value_type nicht unordered_map-weise aus dem entsprechenden Ausdruck konstruierbar ist (EmplaceConstructible), ist das Verhalten undefiniert.

3) Diese Überladung nimmt nur an der Auflösung von Überladungen teil, wenn alle folgenden Bedingungen erfüllt sind

• std::is_convertible_v<K&&, const_iterator> und std::is_convertible_v<K&&, iterator> sind beide false.
• Hash::is_transparent und KeyEqual::is_transparent sind gültig und bezeichnen jeweils einen Typ.

Wenn hash_function()(u.first) != hash_function()(k) || contains(u.first) true ist, ist das Verhalten undefiniert, wobei u das neu einzufügende Element ist.

6) Diese Überladung nimmt nur an der Overload Resolution teil, wenn Hash::is_transparent und KeyEqual::is_transparent beide gültig sind und jeweils einen Typ bezeichnen.

Wenn hash_function()(u.first) != hash_function()(k) || contains(u.first) true ist, ist das Verhalten undefiniert, wobei u das neu einzufügende Element ist.

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

Parameter

k	-	der Schlüssel, der sowohl zur Suche als auch zum Einfügen verwendet wird, wenn er nicht gefunden wird
hint	-	Iterator zu der Position, vor der das neue Element eingefügt wird
args	-	Argumente, die an den Konstruktor des Elements weitergeleitet werden

Rückgabewert

1-3) Wie für emplace
Ein Paar, das aus einem Iterator zu dem eingefügten Element (oder zu dem Element, das die Einfügung verhindert hat) und einem bool-Wert besteht, der genau dann true ist, wenn die Einfügung stattgefunden hat.

4-6) Wie für emplace_hint
Ein Iterator zu dem eingefügten Element oder zu dem Element, das die Einfügung verhindert hat.

Komplexität

1-3) Wie für emplace
Im Durchschnitt amortisiert konstant, im schlimmsten Fall linear zur Größe des Containers.

4-6) Wie für emplace_hint
Im Durchschnitt amortisiert konstant, im schlimmsten Fall linear zur Größe des Containers.

Anmerkungen

Im Gegensatz zu insert oder emplace verschieben diese Funktionen keine R-Wert-Argumente, wenn die Einfügung nicht stattfindet. Dies erleichtert die Manipulation von Maps, deren Werte nur verschiebbar sind (move-only types), wie z.B. std::unordered_map<std::string, std::unique_ptr<foo>>. Darüber hinaus behandelt try_emplace den Schlüssel und die Argumente für den mapped_type separat, im Gegensatz zu emplace, das Argumente zur Konstruktion eines value_type (d.h. eines std::pair) benötigt.

Die Überladungen (3,6) können aufgerufen werden, ohne ein Objekt vom Typ Key zu konstruieren.

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_unordered_map_try_emplace	201411L	(C++17)	std::unordered_map::try_emplace, std::unordered_map::insert_or_assign
__cpp_lib_associative_heterogeneous_insertion	202311L	(C++26)	Heterogene Überladungen für die verbleibenden Memberfunktionen in geordneten und ungeordneten assoziativen Containern. Überladungen (3) und (6).

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <string>
#include <unordered_map>
#include <utility>
 
void print_node(const auto& node)
{
    std::cout << '[' << node.first << "] = " << node.second << '\n';
}
 
void print_result(auto const& pair)
{
    std::cout << (pair.second ? "inserted: " : "ignored:  ");
    print_node(*pair.first);
}
 
int main()
{
    using namespace std::literals;
    std::unordered_map<std::string, std::string> m;
 
    print_result(m.try_emplace("a", "a"s));
    print_result(m.try_emplace("b", "abcd"));
    print_result(m.try_emplace("c", 10, 'c'));
    print_result(m.try_emplace("c", "Won't be inserted"));
 
    for (const auto& p : m)
        print_node(p);
}

Mögliche Ausgabe

inserted: [a] = a
inserted: [b] = abcd
inserted: [c] = cccccccccc
ignored:  [c] = cccccccccc
[a] = a
[b] = abcd
[c] = cccccccccc

Siehe auch

emplace	konstruiert Elemente direkt (in-place) (public member function)
emplace_hint	konstruiert Elemente "in place" unter Verwendung eines Hinweises (public member function)
insert	fügt Elemente ein oder Knoten(seit C++17) (public member function)