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

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)	(until C++20)

Compares the contents of two unordered containers.

The contents of two unordered containers lhs and rhs are equal if the following conditions hold:

• lhs. size ( ) == rhs. size ( ) .
• each group of equivalent elements [ lhs_eq1 , lhs_eq2 ) obtained from lhs. equal_range ( lhs_eq1 ) has a corresponding group of equivalent elements in the other container [ rhs_eq1 , rhs_eq2 ) obtained from rhs. equal_range ( rhs_eq1 ) , that has the following properties:

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

The behavior is undefined if Key or T are not EqualityComparable .

The behavior is also undefined if hash_function() and key_eq() do (until C++20) key_eq() does (since C++20) not have the same behavior on lhs and rhs or if operator == for Key is not a refinement of the partition into equivalent-key groups introduced by key_eq() (that is, if two elements that compare equal using operator == fall into different partitions).

The != operator is synthesized from operator== .

(since C++20)

Parameters

lhs, rhs

-

unordered containers to compare

Return value

Complexity

Proportional to ΣS _i ² calls to operator == on value_type , calls to the predicate returned by key_eq , and calls to the hasher returned by hash_function in the average case, where S is the size of the i th equivalent key group. Proportional to N ² in the worst case, where N is the size of the container. Average case becomes proportional to N if the elements within each equivalent key group are arranged in the same order (happens when the containers are copies of each other).