std::three_way_comparable, std::three_way_comparable_with

< cpp‎ | utility
 
C++
 
工具库
语言支持
类型支持（基本类型、 RTTI 、类型特征）
库功能特性测试宏 (C++20)
动态内存管理
程序工具
错误处理
协程支持 (C++20)
变参数函数
(C++17)
(C++11)
(C++20)
三路比较 (C++20)
three_way_comparablethree_way_comparable_with
(C++20)(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)(C++20)(C++20)(C++20)(C++20)(C++20)
通用工具
日期和时间
函数对象
格式化库 (C++20)
(C++11)
(C++14)
关系运算符 (C++20 中弃用)
整数比较函数
(C++20)(C++20)(C++20)(C++20)(C++20)(C++20)
(C++20)
swap 与类型运算
(C++20)
(C++14)
(C++11)
(C++11)
(C++11)
(C++11)
(C++17)
常用词汇类型
(C++11)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)

初等字符串转换
(C++17)
(C++17)
(C++17)
 
定义于头文件 <compare>
template<class T, class U>

  concept __PartiallyOrderedWith =      // 仅为阐释
    requires(const std::remove_reference_t<T>& t,
             const std::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;

    };
 (1) (C++20 起)
template<class T, class Cat>

  concept __ComparesAs =                // 仅为阐释

    std::same_as<std::common_comparison_category_t<T, Cat>, Cat>;
 (2) (C++20 起)
template<class T, class Cat = std::partial_ordering>

  concept three_way_comparable =
    __WeaklyEqualityComparableWith<T, T> &&
    __PartiallyOrderedWith<T, T> &&
    requires(const std::remove_reference_t<T>& a,
             const std::remove_reference_t<T>& b) {
      { a <=> b } -> __ComparesAs<Cat>;

    };
 (3) (C++20 起)
template<class T, class U, class Cat = std::partial_ordering>

  concept three_way_comparable_with =
    std::three_way_comparable<T, Cat> &&
    std::three_way_comparable<U, Cat> &&
    std::common_reference_with<
      const std::remove_reference_t<T>&,
      const std::remove_reference_t<U>&> &&
    three_way_comparable<
      std::common_reference_t<
        const std::remove_reference_t<T>&,
        const std::remove_reference_t<U>&>, Cat> &&
    __WeaklyEqualityComparableWith<T, U> &&
    __PartiallyOrderedWith<T, U> &&
    requires(const std::remove_reference_t<T>& t,
             const std::remove_reference_t<U>& u) {
      { t <=> u } -> __ComparesAs<Cat>;
      { u <=> t } -> __ComparesAs<Cat>;

    };
 (4) (C++20 起)
1) 仅用于阐释的概念 __PartiallyOrderedWith<T, U> 指定 T 类型对象与 U 类型对象能（以任何顺序）用 < 、 > 、 <= 及 >= 在一个偏序中彼此比较，且比较结果一致。
更正式而言， T 与 U 实现 __PartiallyOrderedWith<T, U> ，仅若给定

下列为真：

  • t < u 、 t <= u 、 t > u 、 t >= u 、 u < t 、 u <= t 、 u > t 及 u >= t 拥有相同定义域；
  • bool(t < u) == bool(u > t) ；
  • bool(u < t) == bool(t > u) ；
  • bool(t <= u) == bool(u >= t) ；且
  • bool(u <= t) == bool(t >= u) 。
3) 概念 three_way_comparable<T, Cat> 指定三路比较运算符 <=> 在 T 上生成与 Cat 所蕴含的比较类别一致的结果。

T 与 Cat 实现 three_way_comparable<T, Cat> ，仅若给定 const std::remove_reference_t<T> 类型左值 a 与 b ，下列为真：

  • (a <=> b == 0) == bool(a == b) ，
  • (a <=> b != 0) == bool(a != b) ，
  • ((a <=> b) <=> 0) 与 (0 <=> (b <=> a)) 相等，
  • bool(a > b) == bool(b < a) ，
  • bool(a >= b) == !bool(a < b) ，
  • bool(a <= b) == !bool(b < a) ，
  • (a <=> b < 0) == bool(a < b) ，
  • (a <=> b > 0) == bool(a > b) ，
  • (a <=> b <= 0) == bool(a <= b) ，且
  • (a <=> b >= 0) == bool(a >= b) ；而
  • 若 Cat 可转换为 std::strong_ordering ，则 T 实现 totally_ordered 。
4) 概念 three_way_comparable_with<T, U, Cat> 指定三路比较运算符 <=> 在（可能混合的） T 与 U 上操作数上生成与 Cat 所蕴含的比较类别一致的结果。比较混合的操作数生成的结果等价于比较转换到其功用类型的操作数。

正式而言， T 、 U 及 Cat 实现 three_way_comparable_with<T, U, Cat> 仅若给定

令 C 为 std::common_reference_t<const std::remove_reference_t<T>&, const std::remove_reference_t<U>&> ，下列为真：

  • t <=> u 与 u <=> t 拥有相同定义域；
  • ((t <=> u) <=> 0) 与 (0 <=> (u <=> t)) 相等；
  • (t <=> u == 0) == bool(t == u) ，
  • (t <=> u != 0) == bool(t != u) ，
  • Cat(t <=> u) == Cat(C(t) <=> C(u)) ，
  • (t <=> u < 0) == bool(t < u) ，
  • (t <=> u > 0) == bool(t > u) ，
  • (t <=> u <= 0) == bool(t <= u) ，且
  • (t <=> u >= 0) == bool(t >= u) ；而
  • 若 Cat 可转换为 std::strong_ordering ，则 T 与 U 实现 std::totally_ordered_with<T, U> 。

其中 __WeaklyEqualityComparableWith 是仅用于阐释的概念，亦为 equality_comparable 所用。

相等性保持

若表达式对给定的相等输入产生相等输出，则它保持相等性。

  • 表达式的输入由其操作数组成。
  • 表达式的输出由其结果和表达式所修改的所有操作数（若存在）组成。

在标准概念的规范中，操作数定义为仅包含下列内容的最大子表达式：

每个操作数的 cv 限定与值类别，是通过假设每个模板类型形参代表一个 cv 无限定的非数组对象类型确定的。

进一步要求每个要求保持相等性的表达式都稳定：这种表达式带相同输入对象的二次求值必须拥有相等的输出，而无任何对这些输入对象的显式中间修改。

除非另外提醒，每个用于 requires 表达式中的表达式都要求保持相等性且稳定，而表达式的求值必须只修改其非常操作数。必须不修改常操作数。

隐式表达式变种

使用不修改某 const 左值运算数的表达式的 requires 表达式亦隐式要求该表达式的额外变种对给定运算数接受非 const 左值或（可为 const 的）右值，除非以有区别的语义显式要求这种表达式变种。这些隐式表达式变种必须符合与声明的表达式的相同的语义。不指定实现以何种程度校验变种的语法。

参阅

(C++20)
 指定运算符 == 为等价关系
(概念)
(C++20)
 指定比较运算符在该类型上产生全序
(概念)