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

template < class Key, class Hash, class KeyEqual, class Alloc > bool operator == ( const std:: unordered_multiset < Key, Hash, KeyEqual, Alloc > & lhs, const std:: unordered_multiset < Key, Hash, KeyEqual, Alloc > & rhs ) ;	(1)
template < class Key, class Hash, class KeyEqual, class Alloc > bool operator ! = ( const std:: unordered_multiset < Key, Hash, KeyEqual, Alloc > & lhs, const std:: unordered_multiset < Key, Hash, KeyEqual, Alloc > & rhs ) ;	(2)	(jusqu'au C++20)

Compare le contenu de deux conteneurs non ordonnés.

Le contenu de deux conteneurs non ordonnés lhs et rhs sont égaux si les conditions suivantes sont remplies :

• lhs. size ( ) == rhs. size ( ) .
• chaque groupe d'éléments équivalents [ lhs_eq1 , lhs_eq2 ) obtenu à partir de lhs. equal_range ( lhs_eq1 ) possède un groupe correspondant d'éléments équivalents dans l'autre conteneur [ rhs_eq1 , rhs_eq2 ) obtenu à partir de rhs. equal_range ( rhs_eq1 ) , qui possède les propriétés suivantes :

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

Le comportement n'est pas défini si Key n'est pas EqualityComparable .

Le comportement est également indéfini si hash_function() et key_eq() n'ont (jusqu'à C++20) key_eq() n'a (depuis C++20) pas le même comportement sur lhs et rhs ou si operator == pour Key n'est pas un raffinement de la partition en groupes de clés équivalentes introduite par key_eq() (c'est-à-dire, si deux éléments qui comparent égaux en utilisant operator == tombent dans des partitions différentes).

L'opérateur != est synthétisé à partir de operator== .

(depuis C++20)

Paramètres

lhs, rhs

-

conteneurs non ordonnés à comparer

Valeur de retour

Complexité

Proportionnel à ΣS _i ² appels à operator == sur value_type , appels au prédicat retourné par key_eq , et appels au hasher retourné par hash_function dans le cas moyen, où S est la taille du i ème groupe de clés équivalentes. Proportionnel à N ² dans le pire cas, où N est la taille du conteneur. Le cas moyen devient proportionnel à N si les éléments de chaque groupe de clés équivalentes sont arrangés dans le même ordre (se produit lorsque les conteneurs sont des copies les uns des autres).