Namespaces
Variants

std::map<Key,T,Compare,Allocator>:: insert

From cppreference.net
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.

1-3) Fügt value ein.
Überladung (2) ist äquivalent zu emplace ( std:: forward < P > ( value ) ) und nimmt nur an der Überladungsauflösung teil, wenn std:: is_constructible < value_type, P && > :: value == true .
4-6) Fügt value an einer Position ein, die so nah wie möglich an der Position direkt vor pos liegt.
Überladung (5) ist äquivalent zu emplace_hint ( pos, std:: forward < P > ( value ) ) und nimmt nur an der Überladungsauflösung teil, wenn std:: is_constructible < value_type, P && > :: value == true .
7) Fügt Elemente aus dem Bereich [ 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 ).
8) Fügt Elemente aus der Initialisierungsliste ilist ein. Wenn mehrere Elemente im Bereich Schlüssel haben, die äquivalent verglichen werden, ist es nicht spezifiziert, welches Element eingefügt wird (ausstehend LWG2844 ).
9) Wenn nh ein leerer node handle ist, erfolgt keine Aktion. Andernfalls wird das von nh verwaltete Element in den Container eingefügt, sofern der Container nicht bereits ein Element mit einem Schlüssel enthält, der äquivalent zu nh. key ( ) ist. Das Verhalten ist undefiniert, wenn nh nicht leer ist und get_allocator ( ) ! = nh. get_allocator ( ) .
10) Wenn nh ein leerer node handle ist, tut nichts und gibt den End-Iterator zurück. Andernfalls fügt das Element, das von nh besessen wird, in den Container ein, falls der Container noch kein Element mit einem Schlüssel enthält, der äquivalent zu nh. key ( ) ist, und gibt den Iterator zurück, der auf das Element mit dem Schlüssel äquivalent zu nh. key ( ) zeigt (unabhängig davon, ob das Einfügen erfolgreich war oder fehlgeschlagen ist). Wenn das Einfügen erfolgreich ist, wird nh verschoben, andernfalls behält es das Eigentum am Element. Das Element wird so nah wie möglich an der Position direkt vor pos eingefügt. Das Verhalten ist undefiniert, wenn nh nicht leer ist und get_allocator ( ) ! = nh. get_allocator ( ) .

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

1-3) Ein Paar bestehend aus einem Iterator zum eingefügten Element (oder zum Element, das die Einfügung verhinderte) und einem bool -Wert, der auf true gesetzt ist, genau dann wenn die Einfügung stattgefunden hat.
4-6) Ein Iterator zum eingefügten Element oder zum Element, das die Einfügung verhindert hat.
7,8) (keine)
9) Ein Objekt vom Typ insert_return_type mit den wie folgt initialisierten Mitgliedern:
  • Wenn nh leer ist, ist inserted false , position ist end ( ) , und node ist leer.
  • Andernfalls, wenn die Einfügung stattgefunden hat, ist inserted true , zeigt position auf das eingefügte Element, und node ist leer.
  • Wenn die Einfügung fehlgeschlagen ist, ist inserted false , hat node den vorherigen Wert von nh , und position zeigt auf ein Element mit einem Schlüssel, der äquivalent zu nh. key ( ) ist.
10) End-Iterator, wenn nh leer war, Iterator, der auf das eingefügte Element zeigt, wenn die Einfügung stattgefunden hat, und Iterator, der auf ein Element mit einem Schlüssel zeigt, der äquivalent zu nh. key ( ) ist, wenn es fehlgeschlagen ist.

Ausnahmen

1-6) Wenn eine Ausnahme durch einen beliebigen Vorgang ausgelöst wird, hat das Einfügen keine Auswirkung.

Komplexität

1-3) Logarithmisch in der Größe des Containers, O(log(size())) .
4-6) Amortisiert konstant, wenn die Einfügung an der Position direkt nach (until C++11) vor (since C++11) pos erfolgt, ansonsten logarithmisch in der Größe des Containers.
7,8) O(N·log(size() + N)) , wobei N die Anzahl der einzufügenden Elemente ist.
9) Logarithmisch in der Größe des Containers, O(log(size())) .
10) Amortisiert konstant, wenn die Einfügung an der Position unmittelbar vor pos erfolgt, andernfalls logarithmisch in der Größe des Containers.

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)
Konstruiert Elemente direkt an Ort und Stelle mit Hinweis
(öffentliche Elementfunktion)
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)