Namespaces
Variants

std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>:: try_emplace

From cppreference.net
C++
Containers library
std::flat_map
Member types
Member functions
Non-member functions
Helper classes
Tags
Deduction guides
template < class ... Args >
std:: pair < iterator, bool > try_emplace ( const key_type & k, Args && ... args ) ;
(1) (seit C++23)
template < class ... Args >
std:: pair < iterator, bool > try_emplace ( key_type && k, Args && ... args ) ;
(2) (seit C++23)
template < class K, class ... Args >
std:: pair < iterator, bool > try_emplace ( K && k, Args && ... args ) ;
(3) (seit C++23)
template < class ... Args >
iterator try_emplace ( const_iterator hint, const key_type & k, Args && ... args ) ;
(4) (seit C++23)
template < class ... Args >
iterator try_emplace ( const_iterator hint, key_type && k, Args && ... args ) ;
(5) (seit C++23)
template < class K, class ... Args >
iterator try_emplace ( const_iterator hint, K && k, Args && ... args ) ;
(6) (seit C++23)

Wenn ein Schlüssel, der k entspricht, bereits im Container existiert, tut dies nichts. Andernfalls fügt es ein neues Element in die zugrunde liegenden Container c mit dem Schlüssel k und dem mit args konstruierten Wert ein.

1,2,4,5) Entspricht: 
auto key_it = ranges::upper_bound(c.keys, k, compare);
auto value_it = c.values.begin() + std::distance(c.keys.begin(), key_it);
c.keys.insert(key_it, std::forward<decltype(k)>(k));
c.values.emplace(value_it, std::forward<Args>(args)...);
3,6) Entspricht: 
auto key_it = ranges::upper_bound(c.keys, k, compare);
auto value_it = c.values.begin() + std::distance(c.keys.begin(), key_it);
c.keys.emplace(key_it, std::forward<K>(k));
c.values.emplace(value_it, std::forward<Args>(args)...);
Die Konvertierung von k in key_type muss ein Objekt u konstruieren, für das find ( k ) == find ( u ) true ist. Andernfalls ist das Verhalten undefiniert.
Diese Überladungen nehmen nur dann an der Überladungsauflösung teil, wenn:
Informationen zur Iterator-Invalidierung sind kopiert von hier

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 .
4-6) Gleich wie für emplace_hint .

Komplexität

1-3) Gleich wie für emplace .
4-6) Gleich wie für emplace_hint .

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:: flat_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,6 ) können aufgerufen werden, ohne ein Objekt vom Typ key_type zu konstruieren.

Beispiel

Code ausführen 
#include <flat_map>
#include <iostream>
#include <string>
#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

Konstruiert Element direkt vor Ort
(öffentliche Elementfunktion)
Konstruiert Elemente direkt vor Ort mit Hinweis
(öffentliche Elementfunktion)
Fügt Elemente ein
(öffentliche Elementfunktion)
Fügt ein Element ein oder weist es dem aktuellen Element zu, falls der Schlüssel bereits existiert
(öffentliche Elementfunktion)