标准库标头 <compare> (C++20)

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

目录 1 概念 2 类 3 定制点对象 4 函数 5 概要 5.1 概念 three_way_comparable 5.2 概念 three_way_comparable_with 5.3 类 std::partial_ordering 5.4 类 std::weak_ordering 5.5 类 std::strong_ordering 5.6 类 std::compare_three_way 5.7 类 std::type_order 6 参阅概念
three_way_comparablethree_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` 的受约束函数对象 (类) [编辑]
type_order (C++26)	实施类型的三路比较 (类模板) [编辑]
定制点对象
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_eqis_neqis_ltis_lteqis_gtis_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 = 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 = /* 未指明 */;
  }

  // 类型排序
  template<class T, class U> struct type_order;

  template<class T, class U>
  constexpr strong_ordering type_order_v = type_order<T, U>::value;
}

概念 `three_way_comparable`

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

template<class T, class U>
concept /*partially-ordered-with*/ = // 仅用于阐释
  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 =
  /*weakly-equality-comparable-with*/<T, T> && /*partially-ordered-with*/<T, T> &&
  requires(const remove_reference_t<T>& a, const remove_reference_t<T>& b) {
    { a <=> b } -> /*compares-as*/<Cat>;
  };
}

概念 `three_way_comparable_with`

namespace std {
template<class T, class U, class Cat = partial_ordering>
concept three_way_comparable_with =
  three_way_comparable<T, Cat> && three_way_comparable<U, Cat> &&
  /*comparison-common-type-with*/<T, U> &&
  three_way_comparable<
    common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>,
    Cat> &&
  /*weakly-equality-comparable-with*/<T, U> && /*partially-ordered-with*/<T, U> &&
  requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) {
    { t <=> u } -> /*compares-as*/<Cat>;
    { u <=> t } -> /*compares-as*/<Cat>;
  };
}

类 `std::partial_ordering`

namespace std {
  class partial_ordering
  {
    int /*value*/;       // 仅用于阐释
    bool /*is-ordered*/; // 仅用于阐释

    // 仅用于阐释的构造函数
    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(/*ord*/::/*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(/*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(/*ord*/::/*equivalent*/);
  inline constexpr weak_ordering weak_ordering::greater(/*ord*/::/*greater*/);
}

类 `std::strong_ordering`

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

    // 仅用于阐释的构造函数
    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(/*ord*/::/*equal*/);
  inline constexpr strong_ordering strong_ordering::equivalent(/*ord*/::/*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 = /* 未指明 */;
  };
}

类 `std::type_order`

namespace std {
  template<class T, class U> struct type_order {
    static constexpr strong_ordering value = /*TYPE-ORDER*/(T, U);
    
    using value_type = strong_ordering;
    
    constexpr operator value_type() const noexcept { return value; }
    constexpr value_type operator()() const noexcept { return value; }
  };
}

参阅

三路比较运算符表达式 lhs <=> rhs (C++20)

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏 (C++20)
语言支持库
概念库 (C++20)
诊断库
内存管理库
元编程库 (C++11)
通用工具库
容器库
迭代器库
范围库 (C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库 (C++17)
并发支持库 (C++11)
执行控制库 (C++26)
技术规范
符号索引
外部库

cppreference.com

搜索

命名空间

语言变体

查看

操作

标准库标头 <compare> (C++20)

目录

概念

类

定制点对象

函数

概要

概念 `three_way_comparable`

概念 `three_way_comparable_with`

类 `std::partial_ordering`

类 `std::weak_ordering`

类 `std::strong_ordering`

类 `std::compare_three_way`

类 `std::type_order`

参阅

导航

工具

cppreference.com

搜索

命名空间

语言变体

查看

操作

标准库标头 <compare> (C++20)

概念

类

定制点对象

函数

概要

概念 three_way_comparable

概念 three_way_comparable_with

类 std::partial_ordering

类 std::weak_ordering

类 std::strong_ordering

类 std::compare_three_way

类 std::type_order

参阅

导航

工具

概念 `three_way_comparable`

概念 `three_way_comparable_with`

类 `std::partial_ordering`

类 `std::weak_ordering`

类 `std::strong_ordering`

类 `std::compare_three_way`

类 `std::type_order`