# std::compare_three_way_result

< cpp‎ | utility

定义于头文件 `<compare>` |  |
template<class T, class U = T> struct compare_three_way_result; |  | (C++20 起)

令 `t` 与 `u` 分别代表 const std::remove_reference_t<T> 与 const std::remove_reference_t<U> 类型的左值，若表达式 t <=> u 良构，则提供等于 decltype(t <=> u) 的成员 typedef `type` ，否则无成员 `type` 。

添加 `compare_three_way_result` 的特化的程序行为未定义。

### 成员类型

名字 | 定义
`type` | operator<=> 在 `T` 与 `U` 的 const 限定左值上的结果类型

### 辅助类型

template<class T, class U = T> using compare_three_way_result_t = typename compare_three_way_result<T>::type; |  | (C++20 起)

### 可能的实现

    // 由 Casey Carter 推荐
    // 参阅： https://github.com/microsoft/STL/pull/385#discussion_r357894054
    template<class T, class U = T>
    using compare_three_way_result_t = decltype(
        std::declval<const std::remove_reference_t<T>&>() <=>
        std::declval<const std::remove_reference_t<U>&>()
    );

    template<class T, class U = T>
    struct compare_three_way_result {};

    template<class T, class U>
        requires requires { typename compare_three_way_result_t<T, U>; }
    struct compare_three_way_result {
        using type = compare_three_way_result_t<T, U>;
    };

### 示例

    #include <compare>
    #include <type_traits>
    #include <iostream>

    template <class Ord>
    void print_cmp_type()
    {
        if constexpr (std::is_same_v<Ord, std::strong_ordering>)
            std::cout << "strong ordering\n";
        else if constexpr (std::is_same_v<Ord, std::weak_ordering>)
            std::cout << "weak ordering\n";
        else if constexpr (std::is_same_v<Ord, std::partial_ordering>)
            std::cout << "partial ordering\n";
        else
            std::cout << "illegal comparison result type\n";
    }

    int main()
    {
        print_cmp_type<std::compare_three_way_result_t<int>>();
        print_cmp_type<std::compare_three_way_result_t<double>>();
    }

输出：

    strong ordering
    partial ordering

### 参阅

partial_ordering (C++20) | 三路比较的结果类型，支持所有 6 种运算符，不可替换，并允许不可比较的值 (类)
weak_ordering (C++20) | 三路比较的结果类型，支持所有 6 种运算符且不可替换 (类)
strong_ordering (C++20) | 三路比较的结果类型，支持所有 6 种运算符且可替换 (类)