std::operators (unordered_multimap)

equality (1)	template <class Key, class T, class Hash, class Pred, class Alloc> bool operator== ( const unordered_multimap<Key,T,Hash,Pred,Alloc>& lhs, const unordered_multimap<Key,T,Hash,Pred,Alloc>& rhs );
inequality (2)	template <class Key, class T, class Hash, class Pred, class Alloc> bool operator!= ( const unordered_multimap<Key,T,Hash,Pred,Alloc>& lhs, const unordered_multimap<Key,T,Hash,Pred,Alloc>& rhs );

equality (1)

template <class Key, class T, class Hash, class Pred, class Alloc>  bool operator== ( const unordered_multimap<Key,T,Hash,Pred,Alloc>& lhs,                    const unordered_multimap<Key,T,Hash,Pred,Alloc>& rhs );

inequality (2)

template <class Key, class T, class Hash, class Pred, class Alloc>  bool operator!= ( const unordered_multimap<Key,T,Hash,Pred,Alloc>& lhs,                    const unordered_multimap<Key,T,Hash,Pred,Alloc>& rhs );

Relational operators for unordered_multimap

These overloaded global operator functions perform the appropriate equality or inequality comparison operation between the unordered_multimap containers lhs and rhs.

The procedure for the equality comparison is as follows (stopping at any point if the procedure finds a conclusive answer):

First, the sizes are compared (size).
For every group with equivalent keys (such as those returned by equal_range):
- sizes are compared (count).
- all possible permutations of each group are compared (permutation).
Note that the unordered_multimap::hash_function and unordered_multimap::key_eq objects are expected to have the same behavior in both lhs and rhs.

Parameters

lhs, rhs: unordered_multimap containers (to the left- and right-hand side of the operator, respectively), having both the same template parameters (Key, T, Hash, Pred and Alloc).

Return Value

true if the condition holds, and false otherwise.

Example

// unordered_multimap comparisons
#include <iostream>
#include <string>
#include <unordered_map>

typedef std::unordered_multimap<std::string,int> stringmap;

int main ()
{
  stringmap a = { {"AAPL",100}, {"MSFT",200}, {"GOOG",50}, {"GOOG",20} };
  stringmap b = { {"GOOG",20}, {"MSFT",200}, {"AAPL",100}, {"GOOG",50} };
  stringmap c = { {"GOOG",70}, {"MSFT",200}, {"AAPL",100} };

  if (a==b) std::cout << "a and b are equal\n";
  if (b!=c) std::cout << "b and c are not equal\n";

  return 0;
}

Output:

a and b are equal
b and c are not equal

Complexity

Average case: linear in number of equivalent groups, where each is up to quadratic in number of elements (general case), but commonly linear if the relative order of elements between the equivalent groups is the same (such as when a container is a copy of another).
Worst case: quadratic in size.

Iterator validity