std::three_way_comparable, std::three_way_comparable_with

来自cppreference.com
< cpp‎ | utility
定义于头文件 <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 } -> std::boolean;
      { t >  u } -> std::boolean;
      { t <= u } -> std::boolean;
      { t >= u } -> std::boolean;
      { u <  t } -> std::boolean;
      { u >  t } -> std::boolean;
      { u <= t } -> std::boolean;
      { u >= t } -> std::boolean;

    };
(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> &&
    (!std::convertible_to<Cat, std::partial_ordering> ||
    __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 =
    __WeaklyEqualityComparableWith<T, U> &&
    (!std::convertible_to<Cat, std::partial_ordering> ||
    __PartiallyOrderedWith<T, U>) &&
    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> &&
    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 类型对象能(以任何顺序)用 <><=>= 在一个偏序中彼此比较,且比较结果一致。
更正式而言, TU 实现 __PartiallyOrderedWith<T, U> ,仅若给定

下列为真:

  • t < ut <= ut > ut >= uu < tu <= tu > tu >= 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 所蕴含的比较类别一致的结果。

TCat 实现 three_way_comparable<T, Cat> ,仅若给定 const std::remove_reference_t<T> 类型左值 ab ,下列为真:

  • (a <=> b == 0) == bool(a == b)
  • (a <=> b != 0) == bool(a != b)
  • ((a <=> b) <=> 0)(0 <=> (b <=> a)) 相等
  • bool(a < b) && bool(b < c)true ,则 bool(a < c)true
  • bool(a > b) == bool(b < a)
  • bool(a >= b) == !bool(a < b)
  • bool(a <= b) == !bool(b < a)
  • Cat 可转换为 std::strong_equality ,则 T 实现 equality_comparable
  • Cat 可转换为 std::partial_ordering ,则:
    • (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> 指定三路比较运算符 <=> 在(可能混合的) TU 上操作数上生成与 Cat 所蕴含的比较类别一致的结果。比较混合的操作数生成的结果等价于比较转换到其功用类型的操作数。

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

Cstd::common_reference_t<const std::remove_reference_t<T>&, const std::remove_reference_t<U>&> ,下列为真:

  • t <=> uu <=> 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))
  • Cat 可转换为 std::strong_equality ,则 TU 实现 std::equality_comparable_with<T, U>
  • Cat 可转换为 std::partial_ordering ,则:
    • (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 ,则 TU 实现 std::totally_ordered_with<T, U>

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

[编辑] 相等性保持

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

  • 表达式的输入由其运算数组成。
  • 表达式的输出由其结果和表达式所修改的所有运算数(若存在)组成。

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

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

[编辑] 隐式表达式变种

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

[编辑] 参阅

指定运算符 == 为等价关系
(概念) [编辑]
指定比较运算符在该类型上产生全序
(概念) [编辑]