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

Since C++20

Header: <set>

Compares the contents of two sets.

# Declarations

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

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

(until C++20)

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

(until C++20)

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

(until C++20)

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

(until C++20)

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

(until C++20)

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

(since C++20)

# Parameters

lhs, rhs: sets 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 <set>
 
int main()
{
    const std::set
        a{1, 2, 3},
        b{1, 2, 3},
        c{7, 8, 9, 10};
 
    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