Namespaces
Variants
Actions

Standard library header <compare> (C++20)

From cppreference.com
< cpp‎ | header
 
C++
 
Standard library headers
 

This header is part of the language support library.

Contents

Concepts

(C++20)
 specifies that operator <=> produces consistent result on given types
(concept) [edit]

Classes

(C++20)
 the result type of 3-way comparison that supports all 6 operators, is not substitutable, and allows incomparable values
(class) [edit]
(C++20)
 the result type of 3-way comparison that supports all 6 operators and is not substitutable
(class) [edit]
(C++20)
 the result type of 3-way comparison that supports all 6 operators and is substitutable
(class) [edit]
(C++20)
 the strongest comparison category to which all of the given types can be converted
(class template) [edit]
(C++20)
 obtains the result type of the three-way comparison operator <=> on given types
(class template) [edit]
(C++20)
 constrained function object implementing x <=> y
(class) [edit]

Customization point objects

(C++20)
 performs 3-way comparison and produces a result of type std::strong_ordering
(customization point object)[edit]
(C++20)
 performs 3-way comparison and produces a result of type std::weak_ordering
(customization point object)[edit]
(C++20)
 performs 3-way comparison and produces a result of type std::partial_ordering
(customization point object)[edit]
(C++20)
 performs 3-way comparison and produces a result of type std::strong_ordering, even if operator<=> is unavailable
(customization point object)[edit]
(C++20)
 performs 3-way comparison and produces a result of type std::weak_ordering, even if operator<=> is unavailable
(customization point object)[edit]
(C++20)
 performs 3-way comparison and produces a result of type std::partial_ordering, even if operator<=> is unavailable
(customization point object)[edit]

Functions

(C++20)
 named comparison functions
(function) [edit]

[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 } ->