Namespaces
Variants

std::map<Key,T,Compare,Allocator>:: try_emplace

From cppreference.net

C++
Containers library
std::map
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
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 ein Schlüssel, der k entspricht, bereits im Container existiert, erfolgt keine Aktion. Andernfalls wird ein neues Element in den Container eingefügt mit dem Schlüssel k und einem mit args konstruierten Wert. 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 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 , mit der Ausnahme, dass das Element 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 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 die 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 equal_range ( u. first ) == equal_range ( k ) false ist, ist das Verhalten undefiniert, wobei u das neue einzufügende Element darstellt.
6) Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn der qualifizierte Bezeichner Compare :: is_transparent gültig ist und einen Typ bezeichnet.
Wenn equal_range ( u. first ) == equal_range ( k ) false ist, ist das Verhalten undefiniert, wobei u das neue einzufügende Element darstellt.

Keine Iteratoren oder Referenzen werden ungü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 :
Logarithmisch in der Größe des Containers.
4-6) Gleich wie für emplace_hint :
Logarithmisch in der Größe des Containers im Allgemeinen, aber amortisiert konstant, wenn das neue Element direkt vor hint eingefügt wird.

Hinweise

Im Gegensatz zu insert oder emplace bewegen diese Funktionen nicht von Rvalue-Argumenten, wenn die Einfügung nicht stattfindet, was die Handhabung von Maps erleichtert, deren Werte nur verschiebbare Typen sind, wie std:: 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_map_try_emplace 201411L (C++17) std::map::try_emplace , std::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 <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::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);
}

Ausgabe: 

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

Siehe auch

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