std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>::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::flat_map

Membertypen

Memberfunktionen

flat_map::flat_map flat_map::operator= Elementzugriff flat_map::at flat_map::operator[] Iteratoren flat_map::beginflat_map::cbegin flat_map::endflat_map::cend flat_map::rbeginflat_map::crbegin flat_map::rendflat_map::crend Suche flat_map::count flat_map::find flat_map::contains flat_map::equal_range    flat_map::lower_bound flat_map::upper_bound Kapazität flat_map::size flat_map::max_size flat_map::empty Modifizierer flat_map::clear flat_map::erase flat_map::swap flat_map::emplace flat_map::extract flat_map::replace flat_map::insert flat_map::insert_range flat_map::insert_or_assign flat_map::emplace_hint flat_map::try_emplace Observer flat_map::key_comp flat_map::keys flat_map::value_comp flat_map::values

Nicht-Member-Funktionen

operator==operator<=>         swap(std::flat_map) erase_if(std::flat_map)

Hilfsklassen

uses_allocator<std::flat_map>

Tags

sorted_unique       sorted_unique_t

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 zu k äquivalent ist, bereits im Container vorhanden ist, tut die Funktion nichts. Andernfalls wird ein neues Element in die zugrunde liegenden Container c mit dem Schlüssel k und dem Wert, konstruiert aus args, eingefügt.

1,2,4,5) Äquivalent zu

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) Äquivalent zu

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) den Wert true ergibt. Andernfalls ist das Verhalten undefiniert.

Diese Überladungen nehmen an der Overload Resolution teil, nur wenn 

• Das qualifizierte ID `Compare::is_transparent` gültig ist und einen Typ bezeichnet.
• std::is_constructible_v<key_type, K> ist true.
• std::is_assignable_v<mapped_type&, Args...> ist true.
• Nur für (3): std::is_convertible_v<K&&, const_iterator> und std::is_convertible_v<K&&, iterator> sind beide false.

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.

4-6) Wie für emplace_hint.

Komplexität

1-3) Wie für emplace.

4-6) Wie für emplace_hint.

Hinweise

Im Gegensatz zu insert oder emplace verschieben diese Funktionen keine Rvalue-Argumente, wenn keine Einfügung stattfindet. Dies erleichtert die Manipulation von Maps, deren Werte nur-verschiebbar sind, wie z.B. std::flat_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_type` zu konstruieren.

Beispiel

Führen Sie diesen Code aus

#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

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 (public member function)
insert_or_assign	fügt ein Element ein oder weist einem vorhandenen Element einen Wert zu, falls der Schlüssel bereits existiert (public member function)