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

 

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

 

std::pair<iterator, bool> insert( const value_type& value );	(1)	(seit C++23)
std::pair<iterator, bool> insert( value_type&& value );	(2)	(seit C++23)
iterator insert( const_iterator pos, const value_type& value );	(3)	(seit C++23)
iterator insert( const_iterator pos, value_type&& value );	(4)	(seit C++23)
template< class P > std::pair<iterator, bool> insert( P&& x );	(5)	(seit C++23)
template< class P > iterator insert( const_iterator pos, P&& x );	(6)	(seit C++23)
template< class InputIt > void einfügen( InputIt first, InputIt last );	(7)	(seit C++23)
template< class InputIt > void insert( std::sorted_unique_t, InputIt first, InputIt last );	(8)	(seit C++23)
void insert( std::initializer_list<key_type> ilist );	(9)	(seit C++23)
void insert( std::sorted_unique_t s, std::initializer_list<key_type> ilist );	(10)	(seit C++23)

Fügt ein oder mehrere Elemente in den Container ein, falls der Container noch kein Element mit einem äquivalenten Schlüssel enthält.

1) Fügt value ein. Äquivalent zu return emplace(value);.

2) Fügt value ein. Äquivalent zu return emplace(std::move(value));.

3) Fügt value an einer Position ein, die so nah wie möglich an der Position direkt vor pos liegt. Äquivalent zu return emplace_hint(pos, value);.

4) Fügt value an einer Position ein, die so nah wie möglich an der Position direkt vor pos liegt. Äquivalent zu return emplace_hint(pos, std::move(value));.

5) Wenn *this bereits ein Element enthält, das transparent mit x als *äquivalent* verglichen wird, tut es nichts. Andernfalls wird x in *this eingefügt, als ob durch emplace(std::forward<P>(x));. Diese Überladung nimmt nur an der Auflösung von Überladungen teil, wenn std::is_constructible_v<pair<key_type, mapped_type>, P> true ist.

6) Wenn *this bereits ein Element enthält, das transparent mit x als *äquivalent* verglichen wird, tut es nichts. Andernfalls wird x in *this an der Position eingefügt, die der Position direkt vor pos am nächsten liegt. Entspricht return emplace_hint(position, std::forward<P>(x));. Diese Überladung nimmt nur an der Auflösung von Überladungen teil, wenn std::is_constructible_v<pair<key_type, mapped_type>, P> true ist.

7) Fügt Elemente aus dem Bereich [first, last) ein, als ob die folgenden Operationen sequenziell ausgeführt würden

1. Fügt Elemente zu c hinzu, als ob durch
   for (; first != last; ++first)
   {
       value_type value = *first;
       c.keys.insert(c.keys.end(), std::move(value.first));
       c.values.insert(c.values.end(), std::move(value.second));
   }
2. Sortiert den Bereich der neu eingefügten Elemente bezüglich value_comp.
3. Führt den resultierenden sortierten Bereich und den sortierten Bereich der bereits vorhandenen Elemente zu einem einzigen sortierten Bereich zusammen.
4. Entfernt doppelte Elemente, als ob durch
   auto zv = std::views::zip(c.keys, c.values);
   auto it = ranges::unique(zv, key_equiv(compare)).begin();
   auto dist = std::distance(zv.begin(), it);
   c.keys.erase(c.keys.begin() + dist, c.keys.end());
   c.values.erase(c.values.begin() + dist, c.values.end());

Kann während der In-Place-Merge-Operation Speicher zuweisen.

Wenn mehrere Elemente im Bereich Schlüssel haben, die äquivalent verglichen werden, ist nicht spezifiziert, welches Element eingefügt wird (abhängig von LWG2844).

8) Fügt Elemente aus dem Bereich [first, last) ein, als ob die folgenden Operationen sequenziell ausgeführt würden

1. Fügt Elemente zu c hinzu, als ob durch
   for (; first != last; ++first)
   {
       value_type value = *first;
       c.keys.insert(c.keys.end(), std::move(value.first));
       c.values.insert(c.values.end(), std::move(value.second));
   }
2. Führt den sortierten Bereich der neu hinzugefügten Elemente und den sortierten Bereich der bereits vorhandenen Elemente zu einem einzigen sortierten Bereich zusammen.
3. Entfernt doppelte Elemente, als ob durch
   auto zv = std::views::zip(c.keys, c.values);
   auto it = ranges::unique(zv, key_equiv(compare)).begin();
   auto dist = std::distance(zv.begin(), it);
   c.keys.erase(c.keys.begin() + dist, c.keys.end());
   c.values.erase(c.values.begin() + dist, c.values.end());

Kann während der In-Place-Merge-Operation Speicher zuweisen.

Wenn mehrere Elemente im Bereich Schlüssel haben, die äquivalent verglichen werden, ist nicht spezifiziert, welches Element eingefügt wird (abhängig von LWG2844).

9) Fügt Elemente aus der Initialisierungsliste ilist ein. Äquivalent zu insert(ilist.begin(), ilist.end());.

Wenn mehrere Elemente im Bereich Schlüssel haben, die äquivalent verglichen werden, ist nicht spezifiziert, welches Element eingefügt wird (abhängig von LWG2844).

10) Fügt Elemente aus der Initialisierungsliste ilist ein. Äquivalent zu insert(s, ilist.begin(), ilist.end());.

Wenn mehrere Elemente im Bereich Schlüssel haben, die äquivalent verglichen werden, ist nicht spezifiziert, welches Element eingefügt wird (abhängig von LWG2844).

Parameter

pos	-	ein Iterator auf die Position, vor der das neue Element eingefügt wird
value	-	ein Elementwert zum Einfügen
first, last	-	das Iteratorenpaar, das den Quell- Bereich der einzufügenden Elemente definiert
ilist	-	eine Initialisierungsliste, aus der die Werte eingefügt werden sollen
x	-	ein Wert eines beliebigen Typs, der transparent mit einem Schlüssel verglichen werden kann
s	-	ein Unterscheidungstag, der angibt, dass die Eingabesequenz sortiert ist (bezüglich value_comp()) und nur eindeutige Elemente enthält
Typanforderungen
- InputIt muss die Anforderungen von LegacyInputIterator erfüllen.

Rückgabewert

1,2) Ein Paar, das aus einem Iterator auf das eingefügte Element (oder auf das Element, das die Einfügung verhindert hat) und einem bool-Wert besteht, der auf true gesetzt ist, wenn und nur wenn die Einfügung stattgefunden hat.

3,4) Ein Iterator auf das eingefügte Element oder auf das Element, das die Einfügung verhindert hat.

5) Ein Paar, bestehend aus einem Iterator auf das eingefügte Element (oder auf das Element, das die Einfügung verhindert hat) und einem bool-Wert, der auf true gesetzt ist, wenn und nur wenn die Einfügung stattgefunden hat.

6) Ein Iterator auf das eingefügte Element oder auf das Element, das die Einfügung verhindert hat.

7-10) (keiner)

Ausnahmen

1-6) Wenn eine Ausnahme bei einer Operation ausgelöst wird, hat die Einfügung keine Auswirkung.

Komplexität

1-6) Linear in size().

7) N + M·log(M), wobei N die size() vor der Operation und M std::distance(first, last) ist.

8) Linear in size().

9) N + M·log(M), wobei N die size() vor der Operation und M ilist.size() ist.

10) Linear in N, wobei N die size() nach der Operation ist.

Hinweise

Die gehintete Einfügung (3,4,6) gibt keinen booleschen Wert zurück, um mit der positionsbezogenen Einfügung in sequenziellen Containern, wie std::vector::insert, kompatibel zu sein. Dies ermöglicht die Erstellung generischer Einfüger wie std::inserter. Eine Möglichkeit, den Erfolg einer gehinteten Einfügung zu überprüfen, ist der Vergleich der size() vor und nach der Operation.

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_or_assign	fügt ein Element ein oder weist einem vorhandenen Element einen Wert zu, falls der Schlüssel bereits existiert (public member function)
inserter	erstellt einen std::insert_iterator vom Typ, der aus dem Argument abgeleitet wird (Funktionsvorlage)