operator==,!=,<,<=,>,>=,<=>(std::multimap) - cppreference.com (original) (raw)

Defined in header
template< class Key, class T, class Compare, class Alloc > bool operator==( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs ); (1) (constexpr since C++26)
template< class Key, class T, class Compare, class Alloc > bool operator!=( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs ); (2) (until C++20)
template< class Key, class T, class Compare, class Alloc > bool operator< ( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs ); (3) (until C++20)
template< class Key, class T, class Compare, class Alloc > bool operator<=( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs ); (4) (until C++20)
template< class Key, class T, class Compare, class Alloc > bool operator> ( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs ); (5) (until C++20)
template< class Key, class T, class Compare, class Alloc > bool operator>=( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs ); (6) (until C++20)
template< class Key, class T, class Compare, class Alloc > /* see below */ operator<=>( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs ); (7) (since C++20) (constexpr since C++26)

Compares the contents of two multimaps.

Let value_type be the value type of multimap (i.e., typename multimap::value_type):

1,2) Checks if the contents of lhs and rhs are equal, that is, they have the same number of elements and each element in lhs compares equal with the element in rhs at the same position.

Equivalent to:

return std::distance(lhs.begin(), lhs.end()) == std::distance(rhs.begin(), rhs.end()) && std::equal(lhs.begin(), lhs.end(), rhs.begin()); (until C++14)
return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); (since C++14)

3-7) Compares the contents of lhs and rhs lexicographically.

If any of the following conditions is satisfied, the behavior is undefined:

If any of the following conditions is satisfied, the behavior is undefined:

The <, <=, >, >=, and != operators are synthesized from operator<=> and operator== respectively. (since C++20)

[edit] Parameters

lhs, rhs - multimaps whose contents to compare

[edit] Return value

Operator lhs and rhsare equal lhs is lexicographically greater rhs is lexicographically greater
operator== true false
operator!= false true
operator< false false true
operator<= true
operator> false true false
operator>= true
operator<=> a value equal to ​0​ a value greater then ​0​ a value less than ​0​

[edit] Complexity

1,2) Constant if lhs and rhs are of different size, otherwise linear in the size of the multimap.

3-7) Linear in the size of the multimap.

[edit] Notes

The relational operators are defined in terms of value_type's operator<. (until C++20)
The relational operators are not defined. The rewritten candidate operator<=> will be selected by overload resolution.operator<=> uses value_type's operator<=> if possible, or value_type's operator< otherwise. Notably, if the value_type does not itself provide operator<=>, but is implicitly convertible to a three-way comparable type, that conversion will be used instead of operator<. (since C++20)

These non-member comparison operators do not use Compare to compare elements.

[edit] Example

#include #include #include   int main() { std::multimap<int, char> a{{1, 'a'}, {2, 'b'}, {3, 'c'}}; std::multimap<int, char> b{{1, 'a'}, {2, 'b'}, {3, 'c'}}; std::multimap<int, char> c{{7, 'Z'}, {8, 'Y'}, {9, 'X'}, {10, 'W'}};   assert ("" "Compare equal containers:" && (a != b) == false && (a == b) == true && (a < b) == false && (a <= b) == true && (a > b) == false && (a >= b) == true && (a <=> b) != std::weak_ordering::less && (a <=> b) != std::weak_ordering::greater && (a <=> b) == std::weak_ordering::equivalent && (a <=> b) >= 0 && (a <=> b) <= 0 && (a <=> b) == 0 &&   "Compare non equal containers:" && (a != c) == true && (a == c) == false && (a < c) == true && (a <= c) == true && (a > c) == false && (a >= c) == false && (a <=> c) == std::weak_ordering::less && (a <=> c) != std::weak_ordering::equivalent && (a <=> c) != std::weak_ordering::greater && (a <=> c) < 0 && (a <=> c) != 0 && (a <=> c) <= 0 && ""); }

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 3431 C++20 operator<=> did not require Tto model three_way_comparable requires