std::multimap<Key,T,Compare,Allocator>::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::multimap

Memberfunktionen

multimap::multimap multimap::~multimap        multimap::operator= multimap::get_allocator

Iteratoren multimap::beginmultimap::cbegin (C++11) multimap::endmultimap::cend (C++11) multimap::rbeginmultimap::crbegin (C++11)    multimap::rendmultimap::crend (C++11) Kapazität multimap::size multimap::max_size multimap::empty Observer multimap::key_comp multimap::value_comp Modifizierer multimap::clear multimap::insert multimap::erase multimap::swap multimap::merge (C++17) multimap::insert_range (C++23) multimap::emplace (C++11) multimap::emplace_hint (C++11) multimap::extract (C++17) Suche multimap::count multimap::find multimap::contains (C++20) multimap::equal_range multimap::lower_bound multimap::upper_bound

Nicht-Member-Funktionen

operator==operator<=> (C++20) std::swap(std::multimap) erase_if(std::multimap) (C++20)   operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)

Deduction guides(C++17)

 

iterator einfügen( const value_type& value );	(1)
iterator einfügen( 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 einfügen( InputIt first, InputIt last );		(7)
void insert( std::initializer_list<value_type> ilist );		(8)	(seit C++11)
iterator einfügen( 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 hat, wird am oberen Ende 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 der Position unmittelbar vor pos am nächsten 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 leeres node handle ist, wird nichts getan. Andernfalls wird das von nh gehaltene Element in den Container eingefügt und ein Iterator, der auf das eingefügte Element zeigt, zurückgegeben. Wenn ein Bereich mit Elementen mit Schlüsseln, die zu nh.key() äquivalent sind, 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 leeres node handle ist, wird nichts getan und der End-Iterator zurückgegeben. Andernfalls wird das von nh gehaltene Element in den Container eingefügt und der Iterator zurückgegeben, der auf das Element mit einem Schlüssel zeigt, der zu nh.key() äquivalent ist. Das Element wird so nah wie möglich an die Position unmittelbar 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 auf dieses Element, die vor der Extraktion erhalten wurden, werden gültig.(seit C++17)

Parameter

pos	-	Iterator zu der Position, vor der das neue Element eingefügt wird
value	-	Elementwert, der eingefügt werden soll
first, last	-	das Iteratorenpaar, das den Quell- Bereich der einzufügenden Elemente definiert
ilist	-	Initialisierungsliste, aus der die Werte eingefügt werden sollen
nh	-	ein kompatibler Node Handle
Typanforderungen
- InputIt muss die Anforderungen von LegacyInputIterator erfüllen.

Rückgabewert

1-6) Ein Iterator zum eingefügten Element.

7,8) (keiner)

9,10) End-Iterator, wenn nh leer war, ansonsten Iterator, der auf das eingefügte Element zeigt.

Ausnahmen

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

7,8) Keine Garantie für Ausnahmensicherheit.

9,10) Wenn eine Ausnahme durch eine Operation ausgelöst wird, hat die Einfügung keine Auswirkungen.

Komplexität

1-3) O(log(size()))

4-6) Amortisiert konstant, wenn die Einfügung an der Position unmittelbar vor pos erfolgt, ansonsten O(log(size())).

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, ansonsten O(log(size())).

Beispiel

Führen Sie diesen Code aus

#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()
{
    // list-initialize
    std::multimap<int, std::string, std::greater<int>> mmap
        {{2, "foo"}, {2, "bar"}, {3, "baz"}, {1, "abc"}, {5, "def"}};
    print("#1", mmap);
 
    // insert using value_type
    mmap.insert(decltype(mmap)::value_type(5, "pqr"));
    print("#2", mmap);
 
    // insert using pair
    mmap.insert(std::pair{6, "uvw"});
    print("#3", mmap);
 
    mmap.insert({7, "xyz"});
    print("#4", mmap);
 
    // insert using initializer_list
    mmap.insert({{5, "one"}, {5, "two"}});
    print("#5", mmap);
 
    // insert using a pair of iterators
    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	Korrigiertes Verhalten
LWG 233	C++98	pos war nur ein Hinweis, er konnte komplett ignoriert werden	die Einfügung musste so nah wie möglich an der Position direkt vor pos erfolgen
LWG 264	C++98	die Komplexität der Überladung (5) sollte linear sein, wenn der Bereich [first, last) gemäß Compare sortiert ist.	die lineare Anforderung entfernt in diesem Sonderfall
LWG 371	C++98	die Reihenfolge äquivalenter Elemente war nicht garantiert erhalten zu bleiben	musste erhalten bleiben
LWG 2005	C++11	Überladungen (3,6) waren schlecht beschrieben	verbesserte die Beschreibung

Siehe auch

emplace (C++11)	konstruiert Elemente direkt (in-place) (public member function)
emplace_hint (C++11)	konstruiert Elemente "in place" unter Verwendung eines Hinweises (public member function)
inserter	erstellt einen std::insert_iterator vom Typ, der aus dem Argument abgeleitet wird (Funktionsvorlage)