std::map<Key,T,Compare,Allocator>:: insert
|
std::
pair
<
iterator,
bool
>
insert
(
const
value_type
&
value
)
;
|
(1) | |
|
template
<
class
P
>
std:: pair < iterator, bool > insert ( P && value ) ; |
(2) | (seit C++11) |
|
std::
pair
<
iterator,
bool
>
insert
(
value_type
&&
value
)
;
|
(3) | (seit C++17) |
| (4) | ||
|
iterator insert
(
iterator pos,
const
value_type
&
value
)
;
|
(bis C++11) | |
|
iterator insert
(
const_iterator pos,
const
value_type
&
value
)
;
|
(seit C++11) | |
|
template
<
class
P
>
iterator insert ( const_iterator pos, P && value ) ; |
(5) | (seit C++11) |
|
iterator insert
(
const_iterator pos, value_type
&&
value
)
;
|
(6) | (seit C++17) |
|
template
<
class
InputIt
>
void insert ( InputIt first, InputIt last ) ; |
(7) | |
|
void
insert
(
std::
initializer_list
<
value_type
>
ilist
)
;
|
(8) | (seit C++11) |
|
insert_return_type insert
(
node_type
&&
nh
)
;
|
(9) | (seit C++17) |
|
iterator insert
(
const_iterator pos, node_type
&&
nh
)
;
|
(10) | (seit C++17) |
Fügt Element(e) in den Container ein, falls der Container noch kein Element mit einem äquivalenten Schlüssel enthält.
[
first
,
last
)
ein. Wenn mehrere Elemente im Bereich Schlüssel haben, die äquivalent verglichen werden, ist nicht spezifiziert, welches Element eingefügt wird (ausstehend
LWG2844
).
Keine Iteratoren oder Referenzen werden ungültig. Wenn die Einfügung erfolgreich ist, werden Zeiger und Referenzen auf das Element, die erhalten wurden während es im Node-Handle gehalten wurde, ungültig, und Zeiger und Referenzen, die auf dieses Element erhalten wurden bevor es extrahiert wurde, werden gültig. (seit C++17)
Inhaltsverzeichnis |
Parameter
| pos | - | Iterator auf die Position, vor der das neue Element eingefügt wird |
| value | - | Einzufügender Elementwert |
| first, last | - | Das Iteratorpaar, das den Bereich der einzufügenden Elemente definiert |
| ilist | - | Initialisierungsliste, aus der die Werte eingefügt werden |
| nh | - | Ein kompatibles Node Handle |
| Typanforderungen | ||
-
InputIt
muss die Anforderungen eines
LegacyInputIterator
erfüllen.
|
||
Rückgabewert
insert_return_type
mit den wie folgt initialisierten Mitgliedern:
-
Wenn
nh
leer ist,
ist
insertedfalse ,positionist end ( ) , undnodeist leer. -
Andernfalls, wenn die Einfügung stattgefunden hat,
ist
insertedtrue , zeigtpositionauf das eingefügte Element, undnodeist leer. -
Wenn die Einfügung fehlgeschlagen ist,
ist
insertedfalse , hatnodeden vorherigen Wert von nh , undpositionzeigt auf ein Element mit einem Schlüssel, der äquivalent zu nh. key ( ) ist.
Ausnahmen
|
Dieser Abschnitt ist unvollständig
Grund: Fälle 7-10 |
Komplexität
O(log(size()))
.
O(N·log(size() + N))
, wobei
N
die Anzahl der einzufügenden Elemente ist.
O(log(size()))
.
Hinweise
Das angedeutete Einfügen
(
(
4-6
)
und
(
10
)
)
gibt kein Boolean zurück, um signaturkompatibel mit positionellem Einfügen bei sequentiellen Containern wie
std::vector::insert
zu sein. Dies ermöglicht die Erstellung generischer Einfüger wie
std::inserter
. Eine Möglichkeit, den Erfolg eines angedeuteten Einfügens zu überprüfen, ist der Vergleich von
size()
vorher und nachher.
Beispiel
#include <iomanip> #include <iostream> #include <map> #include <string> using namespace std::Literale; template<typename It> void print_insertion_status(It it, bool success) { std::cout << "Einfügen von " << it->first << (success ? " erfolgreich\n" : " fehlgeschlagen\n"); } int main() { std::map<std::string, float> heights; // Überladung 3: Einfügen aus Rvalue-Referenz const auto [it_hinata, success] = heights.insert({"Hinata"s, 162.8}); print_insertion_status(it_hinata, success); { // Überladung 1: Einfügen aus lvalue-Referenz const auto [it, success2] = heights.insert(*it_hinata); print_insertion_status(it, success2); } { // Überladung 2: Einfügen durch Weiterleitung an emplace const auto [it, success] = heights.insert(std::pair{"Kageyama", 180.6}); print_insertion_status(it, success); } { // Überladung 6: Einfügen aus Rvalue-Referenz mit Positionshinweis const std::size_t n = std::size(heights); const auto it = heights.insert(it_hinata, {"Azumane"s, 184.7}); print_insertion_status(it, std::size(heights) != n); } { // Überladung 4: Einfügen aus lvalue-Referenz mit Positionshinweis const std::size_t n = std::size(heights); const auto it = heights.insert(it_hinata, *it_hinata); print_insertion_status(it, std::size(heights) != n); } { // Überladung 5: Einfügen durch Weiterleitung an emplace mit Positionshinweis const std::size_t n = std::size(heights); const auto it = heights.insert(it_hinata, std::pair{"Tsukishima", 188.3}); print_insertion_status(it, std::size(heights) != n); } auto node_hinata = heights.extract(it_hinata); std::map<std::string, float> heights2; // Überladung 7: Einfügen aus Iteratorbereich heights2.insert(std::begin(heights), std::end(heights)); // Überladung 8: Einfügen aus initializer_list heights2.insert({{"Kozume"s, 169.2}, {"Kuroo", 187.7}}); // Überladung 9: Knoten einfügen const auto status = heights2.insert(std::move(node_hinata)); print_insertion_status(status.position, status.eingefügt); node_hinata = heights2.extract(status.position); { // Überladung 10: Knoten mit Positionshinweis einfügen const std::size_t n = std::size(heights2); const auto it = heights2.insert(std::begin(heights2), std::move(node_hinata)); print_insertion_status(it, std::size(heights2) != n); } // Ergebnis-Karte ausgeben std::cout << std::left << '\n'; for (const auto& [name, height] : heights2) std::cout << std::setw(10) << name << " | " << height << "cm\n"; }
Ausgabe:
Einfügung von Hinata erfolgreich Einfügung von Hinata fehlgeschlagen Einfügung von Kageyama erfolgreich Einfügung von Azumane erfolgreich Einfügung von Hinata fehlgeschlagen Einfügung von Tsukishima erfolgreich Einfügung von Hinata erfolgreich Einfügung von Hinata erfolgreich Azumane | 184.7cm Hinata | 162.8cm Kageyama | 180.6cm Kozume | 169.2cm Kuroo | 187.7cm Tsukishima | 188.3cm
Fehlerberichte
Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | Angewendet auf | Verhalten wie veröffentlicht | Korrektes Verhalten |
|---|---|---|---|
| LWG 233 | C++98 | pos war nur ein Hinweis, konnte komplett ignoriert werden |
Das Einfügen muss so nah wie möglich
an der Position direkt vor pos erfolgen |
| LWG 264 | C++98 |
Die Komplexität der Überladung
(
7
)
musste linear sein, falls
der Bereich
[
first
,
last
)
gemäß
Compare
sortiert war
|
Die lineare Anforderung wurde
für diesen Spezialfall entfernt |
| LWG 316 | C++98 |
Beim Rückgabewert der Überladung
(
1
)
war nicht spezifiziert,
welcher bool -Wert eine erfolgreiche Einfügung anzeigt |
Erfolg wird durch
true angezeigt |
| LWG 2005 | C++11 | Die Überladungen ( 2 ) und ( 5 ) waren schlecht beschrieben | Die Beschreibung wurde verbessert |
Siehe auch
|
(C++11)
|
Konstruiert Element direkt an Ort und Stelle
(öffentliche Elementfunktion) |
|
(C++11)
|
Konstruiert Elemente direkt an Ort und Stelle mit Hinweis
(öffentliche Elementfunktion) |
|
(C++17)
|
Fügt ein Element ein oder weist es dem aktuellen Element zu, falls der Schlüssel bereits existiert
(öffentliche Elementfunktion) |
|
Erstellt einen
std::insert_iterator
vom aus dem Argument abgeleiteten Typ
(Funktionstemplate) |