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

 

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)

 

node_type extract( const_iterator position );	(1)	(seit C++17)
node_type extract( const Key& k );	(2)	(seit C++17)
template< class K > node_type extract( K&& x );	(3)	(seit C++23)

1) Entkoppelt den Knoten, der das von position zeigende Element enthält, und gibt ein node handle zurück, das ihn besitzt.

2) Wenn der Container ein Element mit einem Schlüssel enthält, der äquivalent zu k ist, wird der Knoten, der das erste solche Element enthält, vom Container getrennt und ein node handle zurückgegeben, der ihn besitzt. Andernfalls wird ein leeres node handle zurückgegeben.

3) Wie (2). Diese Überladung nimmt an der Auflösung von Überladungen nur teil, wenn der qualifizierte Bezeichner Compare::is_transparent gültig ist und einen Typ bezeichnet und weder iterator noch const_iterator implizit von K konvertierbar sind. Sie ermöglicht es, diese Funktion aufzurufen, ohne eine Instanz von Key zu konstruieren.

In beiden Fällen werden keine Elemente kopiert oder verschoben, nur die internen Zeiger der Container-Knoten werden neu ausgerichtet (Neubalancierung kann auftreten, wie bei erase()).

Das Extrahieren eines Knotens macht nur die Iteratoren zu dem extrahierten Element ungültig. Zeiger und Referenzen auf das extrahierte Element bleiben gültig, können aber nicht verwendet werden, solange das Element von einem node handle besessen wird: Sie werden verwendbar, wenn das Element in einen Container eingefügt wird.

Parameter

position	-	ein gültiger Iterator in diesen Container
k	-	ein Schlüssel zum Identifizieren des zu extrahierenden Knotens
x	-	ein Wert eines beliebigen Typs, der transparent mit einem Schlüssel verglichen werden kann, der den zu extrahierenden Knoten identifiziert

Rückgabewert

Ein node handle, das das extrahierte Element besitzt, oder ein leeres node handle, falls das Element in (2,3) nicht gefunden wird.

Ausnahmen

1) Wirft nichts.

2,3) Alle Ausnahmen, die vom Compare-Objekt geworfen werden.

Komplexität

1) Amortisiert konstant.

2,3) log(size())

Hinweise

extract ist der einzige Weg, den Schlüssel eines Map-Elements ohne Reallokation zu ändern

std::map<int, std::string> m{{1, "mango"}, {2, "papaya"}, {3, "guava"}};
auto nh = m.extract(2);
nh.key() = 4;
m.insert(std::move(nh));
// m == {{1, "mango"}, {3, "guava"}, {4, "papaya"}}

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_associative_heterogeneous_erasure	202110L	(C++23)	Heterogene Löschung in assoziiativen Containern und nicht geordneten assoziativen Containern, (3)

Beispiel

Führen Sie diesen Code aus

#include <algorithm>
#include <iostream>
#include <string_view>
#include <map>
 
void print(std::string_view comment, const auto& data)
{
    std::cout << comment;
    for (auto [k, v] : data)
        std::cout << ' ' << k << '(' << v << ')';
 
    std::cout << '\n';
}
 
int main()
{
    std::multimap<int, char> cont{{1, 'a'}, {2, 'b'}, {3, 'c'}};
 
    print("Start:", cont);
 
    // Extract node handle and change key
    auto nh = cont.extract(1);
    nh.key() = 4;
 
    print("After extract and before insert:", cont);
 
    // Insert node handle back
    cont.insert(std::move(nh));
 
    print("End:", cont);
}

Ausgabe

Start: 1(a) 2(b) 3(c)
After extract and before insert: 2(b) 3(c)
End: 2(b) 3(c) 4(a)

Siehe auch

merge (C++17)	fügt Knoten aus einem anderen Container zusammen (public member function)
insert	fügt Elemente ein oder Knoten(seit C++17) (public member function)
erase	entfernt Elemente (public member function)