Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::unordered_map
Member types
Member functions
Non-member functions
Deduction guides (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 bereits ein Schlüssel vorhanden ist, der k entspricht, wird nichts unternommen. Andernfalls wird ein neues Element in den Container eingefügt mit dem Schlüssel k und einem Wert, der mit args konstruiert wird. 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 EmplaceConstructible in unordered_map vom entsprechenden Ausdruck ist, ist das Verhalten undefiniert.
3) Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:
Wenn hash_function ( ) ( u. first ) ! = hash_function ( ) ( k ) || contains ( u. first ) true ist, ist das Verhalten undefiniert, wobei u das neue einzufügende Element ist.
6) Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn Hash :: is_transparent und KeyEqual :: is_transparent beide gültig sind und jeder einen Typ bezeichnet.
Wenn hash_function ( ) ( u. first ) ! = hash_function ( ) ( k ) || contains ( u. first ) true ist, ist das Verhalten undefiniert, wobei u das neue einzufügende Element ist.

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 (aufgrund der Einfügung), werden alle Iteratoren ungültig. Andernfalls (keine Neuverteilung) bleiben Iteratoren gültig.

Inhaltsverzeichnis

Parameter

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

Rückgabewert

1-3) Gleich wie für emplace :
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.
4-6) Gleich wie für emplace_hint :
Ein Iterator zum eingefügten Element oder zum Element, das die Einfügung verhindert hat.

Komplexität

1-3) Gleich wie für emplace :
Amortisiert konstant im Durchschnitt, im schlimmsten Fall linear in der Größe des Containers.
4-6) Gleich wie für emplace_hint :
Amortisiert konstant im Durchschnitt, im schlimmsten Fall linear in der Größe des Containers.

Hinweise

Im Gegensatz zu insert oder emplace bewegen diese Funktionen keine Rvalue-Argumente, wenn die Einfügung nicht stattfindet, was die Handhabung von Maps erleichtert, deren Werte nur verschiebbare Typen sind, wie std:: unordered_map < std:: string , std:: unique_ptr < foo >> . Zusätzlich behandelt try_emplace den Schlüssel und die Argumente für den mapped_type separat, anders als emplace , das Argumente für die Konstruktion eines value_type (also eines std::pair ) erfordert.

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

Feature-Test Makro Wert Std Funktion
__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

Diesen Code ausführen 
#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

Konstruiert Elemente direkt
(öffentliche Elementfunktion)
Konstruiert Elemente direkt mit Hinweis
(öffentliche Elementfunktion)
Fügt Elemente ein oder Knoten (seit C++17)
(öffentliche Elementfunktion)