operator==,!=(std::unordered_multimap)

 

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::unordered_multimap

Membertypen
Memberfunktionen
unordered_multimap::unordered_multimap unordered_multimap::~unordered_multimap    unordered_multimap::operator= unordered_multimap::get_allocator Iteratoren unordered_multimap::beginunordered_multimap::cbegin unordered_multimap::endunordered_multimap::cend Kapazität unordered_multimap::size unordered_multimap::max_size unordered_multimap::empty Modifizierer unordered_multimap::clear unordered_multimap::insert unordered_multimap::insert_range (C++23) unordered_multimap::emplace unordered_multimap::emplace_hint unordered_multimap::erase unordered_multimap::swap unordered_multimap::extract (C++17) unordered_multimap::merge (C++17)	Suche unordered_multimap::count unordered_multimap::find unordered_multimap::contains (C++20) unordered_multimap::equal_range Bucket-Schnittstelle unordered_multimap::begin(size_type)unordered_multimap::cbegin(size_type) unordered_multimap::end(size_type)unordered_multimap::cend(size_type) unordered_multimap::bucket_count unordered_multimap::max_bucket_count unordered_multimap::bucket_size unordered_multimap::bucket Hash-Politik unordered_multimap::load_factor unordered_multimap::max_load_factor unordered_multimap::rehash unordered_multimap::reserve Observer unordered_multimap::hash_function unordered_multimap::key_eq
Nicht-Member-Funktionen
std::swap(std::unordered_multimap) erase_if(std::unordered_multimap) (C++20)	operator==operator!= (bis C++20)
Deduction guides (C++17)

 

template< class Key, class T, class Hash, class KeyEqual, class Alloc > bool operator==( const std::unordered_multimap<Key, T, Hash, KeyEqual, Alloc>& lhs,                  const std::unordered_multimap<Key, T, Hash, KeyEqual, Alloc>& rhs );	(1)
template< class Key, class T, class Hash, class KeyEqual, class Alloc > bool operator!=( const std::unordered_multimap<Key, T, Hash, KeyEqual, Alloc>& lhs,                  const std::unordered_multimap<Key, T, Hash, KeyEqual, Alloc>& rhs );	(2)	(bis C++20)

Vergleicht die Inhalte von zwei ungeordneten Containern.

Die Inhalte von zwei ungeordneten Containern lhs und rhs sind gleich, wenn die folgenden Bedingungen erfüllt sind:

• lhs.size() == rhs.size().
• jede Gruppe äquivalenter Elemente [lhs_eq1, lhs_eq2), die aus lhs.equal_range(lhs_eq1) erhalten wird, hat eine entsprechende Gruppe äquivalenter Elemente im anderen Container [rhs_eq1, rhs_eq2), die aus rhs.equal_range(rhs_eq1) erhalten wird und die folgenden Eigenschaften aufweist:

• std::distance(lhs_eq1, lhs_eq2) == std::distance(rhs_eq1, rhs_eq2).
• std::is_permutation(lhs_eq1, lhs_eq2, rhs_eq1) == true.

Das Verhalten ist undefiniert, wenn Key oder T nicht EqualityComparable sind.

Das Verhalten ist auch undefiniert, wenn hash_function() und key_eq() nicht das gleiche Verhalten für lhs und rhs aufweisen oder wenn operator== für Key keine Verfeinerung der Partition in äquivalente Schlüsselgruppen ist, die durch key_eq() eingeführt wurde (d. h. wenn zwei Elemente, die mit operator== gleich verglichen werden, in verschiedene Partitionen fallen).

Der Operator != wird aus operator== synthetisiert.

(seit C++20)

Parameter

lhs, rhs

-

Zu vergleichende ungeordnete Container.

Rückgabewert

1) true, wenn die Inhalte der Container gleich sind, andernfalls false.

2) true, wenn die Inhalte der Container nicht gleich sind, andernfalls false.

Komplexität

Proportional zu ΣS_i² Aufrufe von operator== für value_type, Aufrufe des von key_eq zurückgegebenen Prädikats und Aufrufe des von hash_function zurückgegebenen Hashers im Durchschnittsfall, wobei S die Größe der i-ten Gruppe von äquivalenten Schlüsseln ist. Proportional zu N² im schlimmsten Fall, wobei N die Größe des Containers ist. Der Durchschnittsfall wird proportional zu N, wenn die Elemente innerhalb jeder Gruppe von äquivalenten Schlüsseln in der gleichen Reihenfolge angeordnet sind (was passiert, wenn die Container Kopien voneinander sind).