NAME¶

std::compare_three_way_result - std::compare_three_way_result

Synopsis¶

Defined in header <compare>
template<class T, class U = T> (since C++20)
struct compare_three_way_result;

Let t and u denote lvalue of const std::remove_reference_t<T> and const
std::remove_reference_t<U> respectively, if the expression t <=> u is well-formed,
provides the member typedef type equal to decltype(t <=> u), otherwise there is no
member type.

The behavior of a program that adds specializations for compare_three_way_result is
undefined.

Member types¶

Name Definition
type the result type of operator<=> on const-qualified lvalue of T and U

Helper types¶

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

Possible implementation¶

// recommended by Casey Carter
// see also: 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<T, U> {
using type = compare_three_way_result_t<T, U>;
};

Example¶

// Run this code

#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>>();
}

Output:¶

strong ordering
partial ordering

See also¶

partial_ordering the result type of 3-way comparison that supports all 6 operators,
(C++20) is not substitutable, and allows incomparable values
(class)
weak_ordering the result type of 3-way comparison that supports all 6 operators
(C++20) and is not substitutable
(class)
strong_ordering the result type of 3-way comparison that supports all 6 operators
(C++20) and is substitutable
(class)