(std::set) - cppreference.com (original) (raw)

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

Compares the contents of two sets.

Let value_type be the value type of set (i.e., typename set::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:

value_type is not LessThanComparable.
operator< does not establish total order.

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

T does not model three_way_comparable.
operator< is not defined for values of type (possibly const-qualified) value_type.
operator< does not establish total order.

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

[edit] Parameters

lhs, rhs	-	sets 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 set.

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

[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() { 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 && ""); }

[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