# 标准库头文件 <compare>

< cpp‎ | header

此头文件是语言支持库的一部分。

### 概念
three_way_comparable three_way_comparable_with (C++20) | 指定运算符 <=> 在给定类型上产生一致的结果 (概念)
### 类
partial_ordering (C++20) | 三路比较的结果类型，支持所有 6 种运算符，不可替换，并允许不可比较的值 (类)
weak_ordering (C++20) | 三路比较的结果类型，支持所有 6 种运算符且不可替换 (类)
strong_ordering (C++20) | 三路比较的结果类型，支持所有 6 种运算符且可替换 (类)
common_comparison_category (C++20) | 给定的全部类型都能转换到的最强比较类别 (类模板)
compare_three_way_result (C++20) | 获得三路比较运算符 <=> 在给定类型上的结果 (类模板)
compare_three_way (C++20) | 实现 x <=> y 的函数对象 (类)
### 定制点对象
strong_order (C++20) | 进行三路比较并产生 `std::strong_ordering` 类型结果 (定制点对象)
weak_order (C++20) | 进行三路比较并产生 `std::weak_ordering` 类型结果 (定制点对象)
partial_order (C++20) | 进行三路比较并产生 `std::partial_ordering` 类型结果 (定制点对象)
compare_strong_order_fallback (C++20) | 进行三路比较并产生 `std::strong_ordering` 类型的结果，即使 operator<=> 不可用 (定制点对象)
compare_weak_order_fallback (C++20) | 进行三路比较并产生 `std::weak_ordering` 类型的结果，即使 operator<=> 不可用 (定制点对象)
compare_partial_order_fallback (C++20) | 进行三路比较并产生 `std::partial_ordering` 类型的结果，即使 operator<=> 不可用 (定制点对象)
### 函数
is_eq is_neq is_lt is_lteq is_gt is_gteq (C++20) | 具名比较函数 (函数)

### 概要

    namespace std {
      // 比较类别类型
      class partial_ordering;
      class weak_ordering;
      class strong_ordering;

      // 具名比较函数
      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; }

      // 共用比较类别类型
      template<class... Ts>
      struct common_comparison_category {
        using type = /* 见描述 */;
      };
      template<class... Ts>
        using common_comparison_category_t = typename common_comparison_category<Ts...>::type;

      // 概念 three_way_comparable
      template<class T, class Cat = partial_ordering>
        concept three_way_comparable = /* 见描述 */;
      template<class T, class U, class Cat = partial_ordering>
        concept three_way_comparable_with = /* 见描述 */;

      // 三路比较的结果
      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;

      // 类 compare_three_way
      struct compare_three_way;

      // 比较算法
      inline namespace /* 未指明 */ {
        inline constexpr /* 未指明 */ strong_order = /* 未指明 */;
        inline constexpr /* 未指明 */ weak_order = /* 未指明 */;
        inline constexpr /* 未指明 */ partial_order = /* 未指明 */;
        inline constexpr /* 未指明 */ compare_strong_order_fallback = /* 未指明 */;
        inline constexpr /* 未指明 */ compare_weak_order_fallback = /* 未指明 */;
        inline constexpr /* 未指明 */ compare_partial_order_fallback = /* 未指明 */;
      }
    }

#### 概念 `three_way_comparable`

    namespace std {
      template<class T, class Cat>
        concept __ComparesAs =                // 仅用于阐释
          same_as<common_comparison_category_t<T, Cat>, Cat>;

      template<class T, class U>
        concept __PartiallyOrderedWith =      // 仅用于阐释
          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>;
          };
    }

#### 概念 `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>;
          };
    }

#### 类 std::partial_ordering

    namespace std {
      class partial_ordering {
        int value;          // 仅用于阐释
        bool is_ordered;    // 仅用于阐释

        // 仅用于阐释的构造函数
        constexpr explicit
          partial_ordering(eq v) noexcept :
            value(int(v)), is_ordered(true) {}      // 仅用于阐释
        constexpr explicit
          partial_ordering(ord v) noexcept :
            value(int(v)), is_ordered(true) {}     // 仅用于阐释
        constexpr explicit
          partial_ordering(ncmp v) noexcept :
            value(int(v)), is_ordered(false) {}   // 仅用于阐释

      public:
        // 合法值
        static const partial_ordering less;
        static const partial_ordering equivalent;
        static const partial_ordering greater;
        static const partial_ordering unordered;

        // 比较
        friend constexpr bool operator==(partial_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool
          operator==(partial_ordering v, partial_ordering w) noexcept = default;
        friend constexpr bool operator< (partial_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool operator> (partial_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool operator<=(partial_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool operator>=(partial_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool operator< (/* 未指明 */, partial_ordering v) noexcept;
        friend constexpr bool operator> (/* 未指明 */, partial_ordering v) noexcept;
        friend constexpr bool operator<=(/* 未指明 */, partial_ordering v) noexcept;
        friend constexpr bool operator>=(/* 未指明 */, partial_ordering v) noexcept;
        friend constexpr partial_ordering
          operator<=>(partial_ordering v, /* 未指明 */) noexcept;
        friend constexpr partial_ordering
          operator<=>(/* 未指明 */, partial_ordering v) noexcept;
      };

      // 合法值的定义
      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);
    }

#### 类 std::weak_ordering

    namespace std {
      class weak_ordering {
        int value;  // 仅用于阐释

        // 仅用于阐释的构造函数
        constexpr explicit weak_ordering(eq v) noexcept : value(int(v)) {}  // 仅用于阐释
        constexpr explicit weak_ordering(ord v) noexcept : value(int(v)) {} // 仅用于阐释

      public:
        // 合法值
        static const weak_ordering less;
        static const weak_ordering equivalent;
        static const weak_ordering greater;

        // 转换
        constexpr operator partial_ordering() const noexcept;

        // 比较
        friend constexpr bool operator==(weak_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool operator==(weak_ordering v, weak_ordering w) noexcept = default;
        friend constexpr bool operator< (weak_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool operator> (weak_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool operator<=(weak_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool operator>=(weak_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool operator< (/* 未指明 */, weak_ordering v) noexcept;
        friend constexpr bool operator> (/* 未指明 */, weak_ordering v) noexcept;
        friend constexpr bool operator<=(/* 未指明 */, weak_ordering v) noexcept;
        friend constexpr bool operator>=(/* 未指明 */, weak_ordering v) noexcept;
        friend constexpr weak_ordering
          operator<=>(weak_ordering v, /* 未指明 */) noexcept;
        friend constexpr weak_ordering
          operator<=>(/* 未指明 */, weak_ordering v) noexcept;
      };

      // 合法值的定义
      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);
    }

#### 类 std::strong_ordering

    namespace std {
      class strong_ordering {
        int value;  // 仅用于阐释

        // 仅用于阐释的构造函数
        constexpr explicit strong_ordering(eq v) noexcept :
          value(int(v)) {}    // 仅用于阐释
        constexpr explicit strong_ordering(ord v) noexcept :
          value(int(v)) {}   // 仅用于阐释

      public:
        // 合法值
        static const strong_ordering less;
        static const strong_ordering equal;
        static const strong_ordering equivalent;
        static const strong_ordering greater;

        // 转换
        constexpr operator partial_ordering() const noexcept;
        constexpr operator weak_ordering() const noexcept;

        // 比较
        friend constexpr bool operator==(strong_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool
          operator==(strong_ordering v, strong_ordering w) noexcept = default;
        friend constexpr bool operator< (strong_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool operator> (strong_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool operator<=(strong_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool operator>=(strong_ordering v, /* 未指明 */) noexcept;
        friend constexpr bool operator< (/* 未指明 */, strong_ordering v) noexcept;
        friend constexpr bool operator> (/* 未指明 */, strong_ordering v) noexcept;
        friend constexpr bool operator<=(/* 未指明 */, strong_ordering v) noexcept;
        friend constexpr bool operator>=(/* 未指明 */, strong_ordering v) noexcept;
        friend constexpr strong_ordering
          operator<=>(strong_ordering v, /* 未指明 */) noexcept;
        friend constexpr strong_ordering
        operator<=>(/* 未指明 */, strong_ordering v) noexcept;
      };

      // 合法值的定义
      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);
    }

#### 类 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 = /* 未指明 */;
      };
    }

### 参阅