std:: strong_ordering

类类型 std::strong_ordering 是 三路比较 的结果类型，其特性为：

• 支持全部六种关系运算符（ == , != , < , <= , > , >= ）。

• 蕴含可替换性：若 a 等价于 b ，则 f ( a ) 也等价于 f ( b ) ，其中 f 表示仅读取通过实参的公开常量成员可访问的、与比较相关的状态的函数。换言之，等价的值是不可区分的。
• 不允许不可比较的值 ： a < b 、 a == b 或 a > b 中必须有且仅有一个为 true 。

常量

类型 std::strong_ordering 具有四个有效值，通过其类型的常量静态数据成员实现：

转换

std::strong_ordering 是三种比较类别中最严格的：它不能从任何其他类别隐式转换而来，但可以隐式转换为其他两种类别。

比较操作

此类型的值与字面量 ​ 0 ​ 之间定义了比较运算符。这支持表达式 a <=> b == 0 或 a <=> b < 0 ，可用于将三路比较运算符的结果转换为布尔关系；参见 std::is_eq 、 std::is_lt 等。

这些函数对普通的 非限定查找 或 限定查找 不可见，仅当 std::strong_ordering 作为参数的关联类时，才能通过 实参依赖查找 找到它们。

试图将 strong_ordering 与除整数字面量 ​ 0 ​ 之外的任何值进行比较的程序行为是未定义的。

示例

#include <compare>
#include <iostream>
struct Point
{
    int x{}, y{};
    friend constexpr std::strong_ordering operator<=>(Point lhs, Point rhs)
    {
        if (lhs.x < rhs.x or (lhs.x == rhs.x and lhs.y < rhs.y))
            return std::strong_ordering::less;
        if (lhs.x > rhs.x or (lhs.x == rhs.x and lhs.y > rhs.y))
            return std::strong_ordering::greater;
        return std::strong_ordering::equivalent;
    }
    friend std::ostream& operator<<(std::ostream& os, Point s)
    {
        return os << '(' << s.x << ',' << s.y << ')';
    }
};
void print_three_way_comparison(const auto& p, const auto& q)
{
    const auto cmp{p <=> q};
    std::cout << p
              << (cmp < 0 ? " <  " : cmp > 0 ? " >  " : " == " ) // 与0比较
              << q << '\n';
}
void print_two_way_comparison(const auto& p, const auto& q)
{
    std::cout << p
              << (p < q ? " <  " : p > q ? " >  " : " == ") // 比较p和q
              << q << '\n';
}
int main()
{
    const Point p1{0, 1}, p2{0, 1}, p3{0, 2};
    print_three_way_comparison(p1, p2);
    print_two_way_comparison(p1, p2);
    print_three_way_comparison(p2, p3);
    print_two_way_comparison(p2, p3);
    print_three_way_comparison(p3, p2);
    print_two_way_comparison(p3, p2);
}

(0,1) == (0,1)
(0,1) == (0,1)
(0,1) <  (0,2)
(0,1) <  (0,2)
(0,2) >  (0,1)
(0,2) >  (0,1)

参见