std::map<Key,T,Compare,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::map

Memberfunktionen

map::map map::~map               map::operator= map::get_allocator

Elementzugriff map::at map::operator[] Iteratoren map::beginmap::cbegin (C++11) map::endmap::cend (C++11) map::rbeginmap::crbegin (C++11)      map::rendmap::crend (C++11) Kapazität map::size map::max_size map::empty Observer map::key_comp map::value_comp Modifizierer map::clear map::insert map::erase map::swap map::extract (C++17) map::merge (C++17) map::insert_range (C++23) map::insert_or_assign (C++17) map::emplace (C++11) map::emplace_hint (C++11) map::try_emplace (C++17) Suche map::count map::find map::contains (C++20) map::equal_range map::lower_bound map::upper_bound

Nicht-Member-Funktionen

operator==operator<=> (C++20) std::swap(std::map) erase_if(std::map) (C++20)   operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)

Leitfaden zur Ableitung (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 existiert, der äquivalent zu k ist, wird nichts getan. Andernfalls wird ein neues Element in den Container eingefügt mit dem Schlüssel k und dem Wert, konstruiert mit args. In diesem Fall

1) Verhält sich wie emplace, außer dass das Element als konstruiert wird
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 als konstruiert wird
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 als konstruiert wird
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 konstruiert wird
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 als konstruiert wird
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 konstruiert wird
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 aus dem entsprechenden Ausdruck in map EmplaceConstructible ist, 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> beide false sind.
• Der qualifizierte Bezeichner Compare::is_transparent ist gültig und bezeichnet einen Typ.

Wenn equal_range(u.first) == equal_range(k) false ist, ist das Verhalten undefiniert, wobei u das einzufügende neue Element ist.

6) Diese Überladung nimmt nur an der Auflösung von Überladungen 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 einzufügende neue Element ist.

Keine Iteratoren oder Referenzen werden 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
Logarithmisch zur Größe des Containers.

4-6) Wie für emplace_hint
Logarithmisch zur 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 verschieben diese Funktionen keine Rvalue-Argumente, wenn die Einfügung nicht stattfindet. Dies erleichtert die Handhabung von Maps, deren Werte verschiebbare Typen sind, wie z. B. std::map<std::string, std::unique_ptr<foo>>. Darüber hinaus behandelt try_emplace den Schlüssel und die Argumente für den mapped_type getrennt, im Gegensatz zu emplace, das Argumente zum Konstruieren 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_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

Führen Sie diesen Code aus

#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

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