Standard library header <compare> (C++20)
From cppreference.com
C++
Feature test macros (C++20)
Concepts library (C++20)
Metaprogramming library (C++11)
Ranges library (C++20)
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Standard library headers
<compare> (C++20)
<contracts> (C++26)
<coroutine> (C++20)
<cstdint> (C++11)
<source_location> (C++20)
<stdfloat> (C++23)
<version> (C++20)
<concepts> (C++20)
<debugging> (C++26)
<stacktrace> (C++23)
<system_error> (C++11)
<memory_resource> (C++17)
<scoped_allocator> (C++11)
<type_traits> (C++11)
<ratio> (C++11)
<any> (C++17)
<bit> (C++20)
<charconv> (C++17)
<expected> (C++23)
<format> (C++20)
<optional> (C++17)
<stdbit.h> (C++26)
<tuple> (C++11)
<typeindex> (C++11)
<variant> (C++17)
<array> (C++11)
<flat_map> (C++23)
<flat_set> (C++23)
<forward_list> (C++11)
<hive> (C++26)
<mdspan> (C++23)
<span> (C++20)
<unordered_map> (C++11)
<unordered_set> (C++11)
<generator> (C++23)
<ranges> (C++20)
<cuchar> (C++11)
<string_view> (C++17)
<codecvt> (C++11/17/26*)
<regex> (C++11)
<cfenv> (C++11)
<linalg> (C++26)
<numbers> (C++20)
<random> (C++11)
<simd> (C++26)
<stdckdint.h> (C++26)
<chrono> (C++11)
<ccomplex> (C++11/17/20*)
<ciso646> (until C++20)
<cstdalign> (C++11/17/20*)
<cstdbool> (C++11/17/20*)
<ctgmath> (C++11/17/20*)
<cinttypes> (C++11)
<filesystem> (C++17)
<print> (C++23)
<spanstream> (C++23)
<strstream> (C++98/26*)
<syncstream> (C++20)
<atomic> (C++11)
<barrier> (C++20)
<condition_variable> (C++11)
<future> (C++11)
<hazard_pointer> (C++26)
<latch> (C++20)
<mutex> (C++11)
<rcu> (C++26)
<semaphore> (C++20)
<shared_mutex> (C++14)
<stdatomic.h> (C++23)
<stop_token> (C++20)
<thread> (C++11)
<execution> (C++17)
This header is part of the language support library.
Contents
Concepts
Classes
(C++20)
(class) [edit]
(C++20)
(class) [edit]
(C++20)
(class) [edit]
(C++20)
(class template) [edit]
(C++20)
(class template) [edit]
Customization point objects
(C++20)
std::strong_ordering(customization point object)[edit]
(C++20)
std::weak_ordering(customization point object)[edit]
(C++20)
std::partial_ordering(customization point object)[edit]
(C++20)
std::strong_ordering, even if operator<=> is unavailable(customization point object)[edit]
(C++20)
std::weak_ordering, even if operator<=> is unavailable(customization point object)[edit]
(C++20)
std::partial_ordering, even if operator<=> is unavailable(customization point object)[edit]
Functions
[edit] Synopsis
namespace std { // comparison category types class partial_ordering; class weak_ordering; class strong_ordering; // named comparison functions constexpr bool is_eq (partial_ordering cmp) noexcept { return cmp == 0; } constexpr bool is_neq (partial_ordering cmp) noexcept { return cmp != 0; } constexpr bool is_lt (partial_ordering cmp) noexcept { return cmp < 0; } constexpr bool is_lteq(partial_ordering cmp) noexcept { return cmp <= 0; } constexpr bool is_gt (partial_ordering cmp) noexcept { return cmp > 0; } constexpr bool is_gteq(partial_ordering cmp) noexcept { return cmp >= 0; } // common comparison category type template<class... Ts> struct common_comparison_category { using type = /* see description */; }; template<class... Ts> using common_comparison_category_t = typename common_comparison_category<Ts...>::type; // concept three_way_comparable template<class T, class Cat = partial_ordering> concept three_way_comparable = /* see description */; template<class T, class U, class Cat = partial_ordering> concept three_way_comparable_with = /* see description */; // result of three-way comparison template<class T, class U = T> struct compare_three_way_result; template<class T, class U = T> using compare_three_way_result_t = typename compare_three_way_result<T, U>::type; // class compare_three_way struct compare_three_way; // comparison algorithms inline namespace /* unspecified */ { inline constexpr /* unspecified */ strong_order = /* unspecified */; inline constexpr /* unspecified */ weak_order = /* unspecified */; inline constexpr /* unspecified */ partial_order = /* unspecified */; inline constexpr /* unspecified */ compare_strong_order_fallback = /* unspecified */; inline constexpr /* unspecified */ compare_weak_order_fallback = /* unspecified */; inline constexpr /* unspecified */ compare_partial_order_fallback = /* unspecified */; } }
[edit] Concept three_way_comparable
namespace std { template<class T, class Cat> concept __ComparesAs = // exposition only same_as<common_comparison_category_t<T, Cat>, Cat>; template<class T, class U> concept __PartiallyOrderedWith = // exposition only requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) { { t < u } -> boolean-testable ; { t > u } -> boolean-testable ; { t <= u } -> boolean-testable ; { t >= u } -> boolean-testable ; { u < t } -> boolean-testable ; { u > t } -> boolean-testable ; { u <= t } -> boolean-testable ; { u >= t } -> boolean-testable ; }; template<class T, class Cat = partial_ordering> concept three_way_comparable = __WeaklyEqualityComparableWith<T, T> && __PartiallyOrderedWith<T, T> && requires(const remove_reference_t<T>& a, const remove_reference_t<T>& b) { { a <=> b } -> __ComparesAs<Cat>; }; }
[edit] Concept three_way_comparable_with
namespace std { template<class T, class U, class Cat = partial_ordering> concept three_way_comparable_with = __WeaklyEqualityComparableWith<T, U> && __PartiallyOrderedWith<T, U> && three_way_comparable<T, Cat> && three_way_comparable<U, Cat> && common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> && three_way_comparable< common_reference_t< const remove_reference_t<T>&, const remove_reference_t<U>&>, Cat> && requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) { { t <=> u } -> __ComparesAs<Cat>; { u <=> t } -> __ComparesAs<Cat>; }; }
[edit] Class std::partial_ordering
namespace std { class partial_ordering { int value; // exposition only bool is_ordered; // exposition only // exposition-only constructors constexpr explicit partial_ordering(eq v) noexcept : value(int(v)), is_ordered(true) {} // exposition only constexpr explicit partial_ordering(ord v) noexcept : value(int(v)), is_ordered(true) {} // exposition only constexpr explicit partial_ordering(ncmp v) noexcept : value(int(v)), is_ordered(false) {} // exposition only public: // valid values static const partial_ordering less; static const partial_ordering equivalent; static const partial_ordering greater; static const partial_ordering unordered; // comparisons friend constexpr bool operator==(partial_ordering v, /* unspecified */) noexcept; friend constexpr bool operator==(partial_ordering v, partial_ordering w) noexcept = default; friend constexpr bool operator< (partial_ordering v, /* unspecified */) noexcept; friend constexpr bool operator> (partial_ordering v, /* unspecified */) noexcept; friend constexpr bool operator<=(partial_ordering v, /* unspecified */) noexcept; friend constexpr bool operator>=(partial_ordering v, /* unspecified */) noexcept; friend constexpr bool operator< (/* unspecified */, partial_ordering v) noexcept; friend constexpr bool operator> (/* unspecified */, partial_ordering v) noexcept; friend constexpr bool operator<=(/* unspecified */, partial_ordering v) noexcept; friend constexpr bool operator>=(/* unspecified */, partial_ordering v) noexcept; friend constexpr partial_ordering operator<=>(partial_ordering v, /* unspecified */) noexcept; friend constexpr partial_ordering operator<=>(/* unspecified */, partial_ordering v) noexcept; }; // valid values' definitions inline constexpr partial_ordering partial_ordering::less(ord::less); inline constexpr partial_ordering partial_ordering::equivalent(eq::equivalent); inline constexpr partial_ordering partial_ordering::greater(ord::greater); inline constexpr partial_ordering partial_ordering::unordered(ncmp::unordered); }
[edit] Class std::weak_ordering
namespace std { class weak_ordering { int value; // exposition only // exposition-only constructors constexpr explicit weak_ordering(eq v) noexcept : value(int(v)) {} // exposition only constexpr explicit weak_ordering(ord v) noexcept : value(int(v)) {} // exposition only public: // valid values static const weak_ordering less; static const weak_ordering equivalent; static const weak_ordering greater; // conversions constexpr operator partial_ordering() const noexcept; // comparisons friend constexpr bool operator==(weak_ordering v, /* unspecified */) noexcept; friend constexpr bool operator==(weak_ordering v, weak_ordering w) noexcept = default; friend constexpr bool operator< (weak_ordering v, /* unspecified */) noexcept; friend constexpr bool operator> (weak_ordering v, /* unspecified */) noexcept; friend constexpr bool operator<=(weak_ordering v, /* unspecified */) noexcept; friend constexpr bool operator>=(weak_ordering v, /* unspecified */) noexcept; friend constexpr bool operator< (/* unspecified */, weak_ordering v) noexcept; friend constexpr bool operator> (/* unspecified */, weak_ordering v) noexcept; friend constexpr bool operator<=(/* unspecified */, weak_ordering v) noexcept; friend constexpr bool operator>=(/* unspecified */, weak_ordering v) noexcept; friend constexpr weak_ordering operator<=>(weak_ordering v, /* unspecified */) noexcept; friend constexpr weak_ordering operator<=>(/* unspecified */, weak_ordering v) noexcept; }; // valid values' definitions inline constexpr weak_ordering weak_ordering::less(ord::less); inline constexpr weak_ordering weak_ordering::equivalent(eq::equivalent); inline constexpr weak_ordering weak_ordering::greater(ord::greater); }
[edit] Class std::strong_ordering
namespace std { class strong_ordering { int value; // exposition only // exposition-only constructors constexpr explicit strong_ordering(eq v) noexcept : value(int(v)) {} // exposition only constexpr explicit strong_ordering(ord v) noexcept : value(int(v)) {} // exposition only public: // valid values static const strong_ordering less; static const strong_ordering equal; static const strong_ordering equivalent; static const strong_ordering greater; // conversions constexpr operator partial_ordering() const noexcept; constexpr operator weak_ordering() const noexcept; // comparisons friend constexpr bool operator==(strong_ordering v, /* unspecified */) noexcept; friend constexpr bool operator==(strong_ordering v, strong_ordering w) noexcept = default; friend constexpr bool operator< (strong_ordering v, /* unspecified */) noexcept; friend constexpr bool operator> (strong_ordering v, /* unspecified */) noexcept; friend constexpr bool operator<=(strong_ordering v, /* unspecified */) noexcept; friend constexpr bool operator>=(strong_ordering v, /* unspecified */) noexcept; friend constexpr bool operator< (/* unspecified */, strong_ordering v) noexcept; friend constexpr bool operator> (/* unspecified */, strong_ordering v) noexcept; friend constexpr bool operator<=(/* unspecified */, strong_ordering v) noexcept; friend constexpr bool operator>=(/* unspecified */, strong_ordering v) noexcept; friend constexpr strong_ordering operator<=>(strong_ordering v, /* unspecified */) noexcept; friend constexpr strong_ordering operator<=>(/* unspecified */, strong_ordering v) noexcept; }; // valid values' definitions inline constexpr strong_ordering strong_ordering::less(ord::less); inline constexpr strong_ordering strong_ordering::equal(eq::equal); inline constexpr strong_ordering strong_ordering::equivalent(eq::equivalent); inline constexpr strong_ordering strong_ordering::greater(ord::greater); }
[edit] Class std::compare_three_way
namespace std { struct compare_three_way { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const; using is_transparent = /* unspecified */; }; }