operator==,!=,<,<=,>,>=,<=>(std::map)

Since C++20

Header: <map>

Compares the contents of two maps.

# Declarations

template< class Key, class T, class Compare, class Alloc >
bool operator==( const std::map<Key, T, Compare, Alloc>& lhs,
const std::map<Key, T, Compare, Alloc>& rhs );

template< class Key, class T, class Compare, class Alloc >
bool operator!=( const std::map<Key, T, Compare, Alloc>& lhs,
const std::map<Key, T, Compare, Alloc>& rhs );

(until C++20)

template< class Key, class T, class Compare, class Alloc >
bool operator<( const std::map<Key, T, Compare, Alloc>& lhs,
const std::map<Key, T, Compare, Alloc>& rhs );

(until C++20)

template< class Key, class T, class Compare, class Alloc >
bool operator<=( const std::map<Key, T, Compare, Alloc>& lhs,
const std::map<Key, T, Compare, Alloc>& rhs );

(until C++20)

template< class Key, class T, class Compare, class Alloc >
bool operator>( const std::map<Key, T, Compare, Alloc>& lhs,
const std::map<Key, T, Compare, Alloc>& rhs );

(until C++20)

template< class Key, class T, class Compare, class Alloc >
bool operator>=( const std::map<Key, T, Compare, Alloc>& lhs,
const std::map<Key, T, Compare, Alloc>& rhs );

(until C++20)

template< class Key, class T, class Compare, class Alloc >
synth-three-way-result<T>
operator<=>( const std::map<Key, T, Compare, Alloc>& lhs,
const std::map<Key, T, Compare, Alloc>& rhs );

(since C++20)

# Parameters

lhs, rhs: maps whose contents to compare

# Notes

The relational operators are defined in terms of the element type’s operator<.

The relational operators are defined in terms of synth-three-way, which uses operator<=> if possible, or operator< otherwise.

Notably, if the element does not itself provide operator<=>, but is implicitly convertible to a three-way comparable type, that conversion will be used instead of operator<.

# Example

#include <cassert>
#include <compare>
#include <map>
 
int main()
{
    std::map<int, char> a{{1, 'a'}, {2, 'b'}, {3, 'c'}};
    std::map<int, char> b{{1, 'a'}, {2, 'b'}, {3, 'c'}};
    std::map<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 &&
    "");
}

# Defect reports

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