std:: unordered_multimap

From de.cppreference.net

Definiert im Header `<unordered_map>`
template < class Key, class T, class Hash = std:: hash < Key > , class KeyEqual = std:: equal_to < Key > , class Allocator = std:: allocator < std:: pair < const Key, T >> > class unordered_multimap ;	(1)	(seit C++11)
namespace pmr { template < class Key, class T, class Hash = std:: hash < Key > , class Pred = std:: equal_to < Key > > using unordered_multimap = std :: unordered_multimap < Key, T, Hash, Pred, std:: pmr :: polymorphic_allocator < std:: pair < const Key, T >>> ; }	(2)	(seit C++17)

std::unordered_multimap ist ein ungeordneter assoziativer Container, der äquivalente Schlüssel unterstützt (ein unordered_multimap kann mehrere Kopien jedes Schlüsselwerts enthalten) und Werte eines anderen Typs mit den Schlüsseln verknüpft. Die unordered_multimap-Klasse unterstützt Vorwärtsiteratoren. Suche, Einfügung und Entfernung haben durchschnittlich konstante Zeitkomplexität.

Internally sind die Elemente nicht in einer bestimmten Reihenfolge sortiert, sondern in Buckets organisiert. In welchen Bucket ein Element platziert wird, hängt vollständig vom Hash seines Schlüssels ab. Dies ermöglicht schnellen Zugriff auf einzelne Elemente, da sobald der Hash berechnet ist, dieser auf den exakten Bucket verweist, in dem das Element platziert wurde.

Die Iterationsreihenfolge dieses Containers muss nicht stabil sein (daher kann beispielsweise std::equal nicht zum Vergleichen zweier std::unordered_multimap s verwendet werden), mit der Ausnahme, dass jede Gruppe von Elementen, deren Schlüssel als äquivalent verglichen werden (Vergleich auf Gleichheit mit key_eq() als Komparator), einen zusammenhängenden Teilbereich in der Iterationsreihenfolge bildet, der auch mit equal_range() zugänglich ist.

std::unordered_multimap erfüllt die Anforderungen von Container , AllocatorAwareContainer , UnorderedAssociativeContainer .

Alle Memberfunktionen von


          std::unordered_multimap

sind constexpr : Es ist möglich,


          std::unordered_multimap

-Objekte in der Auswertung eines konstanten Ausdrucks zu erstellen und zu verwenden.

Allerdings können std::unordered_multimap -Objekte im Allgemeinen nicht constexpr sein, da jeder dynamisch allokierte Speicher in derselben Auswertung des konstanten Ausdrucks freigegeben werden muss.

(seit C++26)

Template-Parameter

Dieser Abschnitt ist unvollständig
Grund: Beschreibungen der Template-Parameter hinzufügen.

Mitgliedstypen

Typ	Definition
`key_type`	`Key`
`mapped_type`	`T`
`value_type`	`std::pair<const Key, T>`
`size_type`	vorzeichenloser Ganzzahltyp (üblicherweise std::size_t)
`difference_type`	vorzeichenbehafteter Ganzzahltyp (üblicherweise std::ptrdiff_t)
`hasher`	`Hash`
`key_equal`	`KeyEqual`
`allocator_type`	`Allocator`
`reference`	`value_type&`
`const_reference`	`const value_type&`
`pointer`	`std::allocator_traits<Allocator>::pointer`
`const_pointer`	`std::allocator_traits<Allocator>::const_pointer`
`iterator`	LegacyForwardIterator und ConstexprIterator(seit C++26) zu `value_type`
`const_iterator`	LegacyForwardIterator und ConstexprIterator(seit C++26) zu `const value_type`
`local_iterator`	einem Iteratortyp, dessen Kategorie, Wert-, Differenz-, Zeiger- und Referenztypen dieselben sind wie `iterator`. Dieser Iterator kann verwendet werden, um durch einen einzelnen Bucket zu iterieren, aber nicht über Buckets hinweg.
`const_local_iterator`	einem Iteratortyp, dessen Kategorie, Wert-, Differenz-, Zeiger- und Referenztypen dieselben sind wie `const_iterator`. Dieser Iterator kann verwendet werden, um durch einen einzelnen Bucket zu iterieren, aber nicht über Buckets hinweg.
`node_type` (seit C++17)	eine Spezialisierung von node handle, die einen Container-Knoten repräsentiert

Memberfunktionen

(constructor)	Konstruiert den `unordered_multimap` (öffentliche Member-Funktion)
(destructor)	zerstört die `unordered_multimap` (öffentliche Elementfunktion)
operator=	weist dem Container Werte zu (öffentliche Elementfunktion)
get_allocator	gibt den zugeordneten Allokator zurück (öffentliche Elementfunktion)
Iteratoren
begin cbegin	gibt einen Iterator zum Anfang zurück (öffentliche Elementfunktion)
end cend	gibt einen Iterator zum Ende zurück (public member function)
Kapazität
empty	prüft, ob der Container leer ist (öffentliche Elementfunktion)
size	gibt die Anzahl der Elemente zurück (öffentliche Elementfunktion)
max_size	gibt die maximal mögliche Anzahl von Elementen zurück (öffentliche Elementfunktion)
Modifikatoren
clear	löscht den Inhalt (öffentliche Elementfunktion)
insert	fügt Elemente ein oder Knoten (seit C++17) (öffentliche Elementfunktion)
insert_range (C++23)	fügt eine Reihe von Elementen ein (öffentliche Elementfunktion)
emplace	Konstruiert Elemente direkt (öffentliche Elementfunktion)
emplace_hint	Konstruiert Elemente direkt unter Verwendung eines Hinweises (öffentliche Elementfunktion)
erase	löscht Elemente (öffentliche Elementfunktion)
swap	tauscht die Inhalte aus (öffentliche Elementfunktion)
extract (C++17)	extrahiert Knoten aus dem Container (öffentliche Elementfunktion)
merge (C++17)	verbindet Knoten aus einem anderen Container (öffentliche Elementfunktion)
Lookup
count	gibt die Anzahl der Elemente zurück, die einem bestimmten Schlüssel entsprechen (öffentliche Elementfunktion)
find	findet Element mit spezifischem Schlüssel (öffentliche Elementfunktion)
contains (C++20)	prüft, ob der Container ein Element mit spezifischem Schlüssel enthält (öffentliche Elementfunktion)
equal_range	gibt den Bereich der Elemente zurück, die einem bestimmten Schlüssel entsprechen (öffentliche Elementfunktion)
Bucket-Schnittstelle
begin (size_type) cbegin (size_type)	gibt einen Iterator zum Anfang des angegebenen Buckets zurück (öffentliche Elementfunktion)
end (size_type) cend (size_type)	gibt einen Iterator zum Ende des angegebenen Buckets zurück (öffentliche Elementfunktion)
bucket_count	gibt die Anzahl der Buckets zurück (öffentliche Elementfunktion)
max_bucket_count	gibt die maximale Anzahl von Buckets zurück (öffentliche Elementfunktion)
bucket_size	gibt die Anzahl der Elemente in einem bestimmten Bucket zurück (öffentliche Elementfunktion)
bucket	gibt den Bucket für einen bestimmten Schlüssel zurück (öffentliche Elementfunktion)
Hash-Policy
load_factor	Gibt die durchschnittliche Anzahl von Elementen pro Bucket zurück (öffentliche Elementfunktion)
max_load_factor	verwaltet die maximale durchschnittliche Anzahl von Elementen pro Bucket (öffentliche Elementfunktion)
rehash	reserviert mindestens die angegebene Anzahl von Buckets und regeneriert die Hashtabelle (öffentliche Elementfunktion)
reserve	reserviert Platz für mindestens die angegebene Anzahl von Elementen und regeneriert die Hashtabelle (öffentliche Elementfunktion)
Beobachter
hash_function	Gibt die Funktion zurück, die zum Hashen der Schlüssel verwendet wird (öffentliche Elementfunktion)
key_eq	gibt die Funktion zurück, die zum Vergleichen von Schlüsseln auf Gleichheit verwendet wird (öffentliche Elementfunktion)

Nicht-Member-Funktionen

operator== operator!= (C++11) (C++11) (entfernt in C++20)	vergleicht die Werte im unordered_multimap (Funktions-Template)
std::swap (std::unordered_multimap) (C++11)	spezialisiert den std::swap Algorithmus (Funktions-Template)
erase_if (std::unordered_multimap) (C++20)	löscht alle Elemente, die bestimmte Kriterien erfüllen (Funktions-Template)

Deduktionsleitfäden

(seit C++17)

Hinweise

Feature-Test Makro	Wert	Std	Feature
`__cpp_lib_containers_ranges`	`202202L`	(C++23)	Ranges-Konstruktion und -Einfügung für Container
`__cpp_lib_constexpr_unordered_map`	`202502L`	(C++26)	constexpr `std::unordered_multimap`

Beispiel

Dieser Abschnitt ist unvollständig
Grund: Kein Beispiel

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 2050	C++11	die Definitionen von `reference` , `const_reference` , `pointer` und `const_pointer` basierten auf `allocator_type`	basieren auf `value_type` und std::allocator_traits

Siehe auch

unordered_map (C++11)	Sammlung von Schlüssel-Wert-Paaren, gehasht nach Schlüsseln, Schlüssel sind eindeutig (class template)
multimap	Sammlung von Schlüssel-Wert-Paaren, sortiert nach Schlüsseln (class template)
flat_multimap (C++23)	passt zwei Container an, um eine Sammlung von Schlüssel-Wert-Paaren zu bieten, sortiert nach Schlüsseln (class template)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

node-handle (C++17)
Sequence
array (C++11)
vector
vector <bool>
inplace_vector (C++26)
hive (C++26)
deque
forward_list (C++11)
list
Associative
set
multiset
map
multimap
Unordered associative
unordered_set (C++11)
unordered_multiset (C++11)
unordered_map (C++11)
unordered_multimap (C++11)
Adaptors
stack
queue
priority_queue
flat_set (C++23)
flat_multiset (C++23)
flat_map (C++23)
flat_multimap (C++23)
Views
span (C++20)
mdspan (C++23)
Tables
Iterator invalidation
Member function table
Non-member function table

de.cppreference.net

Namespaces

Variants

std:: unordered_multimap

Inhalt

Template-Parameter

Mitgliedstypen

Memberfunktionen

Iteratoren

Kapazität

Modifikatoren

Lookup

Bucket-Schnittstelle

Hash-Policy