Namespaces
Variants

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

From cppreference.net
C++
Containers library
std::multimap
Member functions
Non-member functions
Deduction guides (C++17)
iterator insert ( const value_type & value ) ;
(1)
iterator insert ( value_type && value ) ;
(2) (seit C++17)
template < class P >
iterator insert ( P && value ) ;
(3) (seit C++11)
(4)
iterator insert ( iterator pos, const value_type & value ) ;
(bis C++11)
iterator insert ( const_iterator pos, const value_type & value ) ;
(seit C++11)
iterator insert ( const_iterator pos, value_type && value ) ;
(5) (seit C++17)
template < class P >
iterator insert ( const_iterator pos, P && value ) ;
(6) (seit C++11)
template < class InputIt >
void insert ( InputIt first, InputIt last ) ;
(7)
void insert ( std:: initializer_list < value_type > ilist ) ;
(8) (seit C++11)
iterator 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.

1-3) Fügt value ein. Wenn der Container Elemente mit äquivalentem Schlüssel enthält, wird an der oberen Grenze dieses Bereichs eingefügt.
Überladung (3) 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 der Position ein, die so nah wie möglich an der Position direkt vor pos liegt.
Überladung (6) ist äquivalent zu emplace_hint ( hint, 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.
8) Fügt Elemente aus der Initialisierungsliste ilist ein.
9) Wenn nh ein leerer node handle ist, erfolgt keine Aktion. Andernfalls wird das von nh verwaltete Element in den Container eingefügt und ein Iterator auf das eingefügte Element zurückgegeben. Falls ein Bereich mit Elementen, deren Schlüssel äquivalent zu nh. key ( ) sind, bereits im Container existiert, wird das Element am Ende dieses Bereichs eingefügt. 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 von nh verwaltete Element in den Container ein und gibt den Iterator zurück, der auf das Element mit einem Schlüssel zeigt, der äquivalent zu nh. key ( ) ist. 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 Quell- 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-6) Ein Iterator auf das eingefügte Element.
7,8) (keine)
9,10) End-Iterator falls nh leer war, ansonsten Iterator, der auf das eingefügte Element zeigt.

Ausnahmen

1-6) Wenn eine Ausnahme durch einen beliebigen Vorgang ausgelöst wird, hat das Einfügen keine Auswirkung.
7,8) Keine Ausnahmesicherheitsgarantie.
9,10) Wenn eine Ausnahme durch eine beliebige Operation ausgelöst wird, hat die Einfügung keine Auswirkung.

Komplexität

1-3) O(log(size()))
4-6) Amortisiert konstant, wenn die Einfügung an der Position unmittelbar vor pos erfolgt, O(log(size())) andernfalls.
7,8) O(N·log(size() + N)) , wobei N die Anzahl der einzufügenden Elemente ist.
9) O(log(size()))
10) Amortisiert konstant, wenn die Einfügung an der Position unmittelbar vor pos erfolgt, O(log(size())) andernfalls.

Beispiel

Diesen Code ausführen 
#include <functional>
#include <iostream>
#include <map>
#include <string>
#include <string_view>
#include <utility>
template<class M>
void print(const std::string_view rem, const M& mmap)
{
    std::cout << rem << ' ';
    for (const auto& e : mmap)
        std::cout << '{' << e.first << ',' << e.second << "} ";
    std::cout << '\n';
}
int main()
{
    // Listeninitialisierung
    std::multimap<int, std::string, std::greater<int>> mmap
        {{2, "foo"}, {2, "bar"}, {3, "baz"}, {1, "abc"}, {5, "def"}};
    print("#1", mmap);
    // Einfügen mit value_type
    mmap.insert(decltype(mmap)::value_type(5, "pqr"));
    print("#2", mmap);
    // Einfügen mit pair
    mmap.insert(std::pair{6, "uvw"});
    print("#3", mmap);
    mmap.insert({7, "xyz"});
    print("#4", mmap);
    // Einfügen mit initializer_list
    mmap.insert({{5, "one"}, {5, "two"}});
    print("#5", mmap);
    // Einfügen mit einem Iteratorpaar
    mmap.clear();
    const auto il = {std::pair{1, "ä"}, {2, "ё"}, {2, "ö"}, {3, "ü"}};
    mmap.insert(il.begin(), il.end());
    print("#6", mmap);
}

Ausgabe: 

#1 {5,def} {3,baz} {2,foo} {2,bar} {1,abc}
#2 {5,def} {5,pqr} {3,baz} {2,foo} {2,bar} {1,abc}
#3 {6,uvw} {5,def} {5,pqr} {3,baz} {2,foo} {2,bar} {1,abc}
#4 {7,xyz} {6,uvw} {5,def} {5,pqr} {3,baz} {2,foo} {2,bar} {1,abc}
#5 {7,xyz} {6,uvw} {5,def} {5,pqr} {5,one} {5,two} {3,baz} {2,foo} {2,bar} {1,abc}
#6 {3,ü} {2,ё} {2,ö} {1,ä}

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 Die Einfügung muss so nah wie möglich
an der Position direkt vor pos erfolgen
LWG 264 C++98 Die Komplexität der Überladung (5) musste linear sein, wenn
der Bereich [ first , last ) gemäß Compare sortiert ist 		Die lineare Anforderung wurde
für diesen Spezialfall entfernt
LWG 371 C++98 Die Reihenfolge äquivalenter Elemente
war nicht garantiert erhalten 		Muss erhalten bleiben
LWG 2005 C++11 Die Überladungen (3,6) waren unzureichend beschrieben Die Beschreibung wurde verbessert

Siehe auch

(C++11)
Konstruiert Element direkt vor Ort
(öffentliche Elementfunktion)
(C++11)
Konstruiert Elemente direkt vor Ort mit Hinweis
(öffentliche Elementfunktion)
erstellt einen std::insert_iterator vom vom Argument abgeleiteten Typ
(Funktionstemplate)