c++ - Operador de implementación<=> para<T> opcional

c++20 spaceship-operator

Question

Con el operator<=> agregado a C ++ 20, quería intentar razonar acerca de cómo implementar este operador para aquellos casos en los que no es una simple comparación entre miembros.

¿Cómo implementaría el operador de la nave espacial para comparar una optional<T> optional<U> con una optional<U> o una U , que es un caso en el que tenemos que comparar la T con la U o comparar los estados subyacentes, obteniendo el tipo de retorno correcto? No hay tal ejemplo en el último artículo .

Answer 1

Creo que la forma correcta de implementar esto sería usar la plantilla de función std::compare_3way() para manejar tanto (1) si esa comparación es viable y (2) cuál es la categoría de comparación en realidad.

Eso hace que la implementación de todos los operadores de comparación sea bastante compacta:

template <typename T>
class optional {
public:
// ...
template <typename U>
constexpr auto operator<=>(optional<U> const& rhs) const
-> decltype(compare_3way(**this, *rhs))
{
if (has_value() && rhs) {
return compare_3way(**this, *rhs);
} else {
return has_value() <=> rhs.has_value();
}
}
template <typename U>
constexpr auto operator<=>(U const& rhs) const
-> decltype(compare_3way(**this, rhs))
{
if (has_value()) {
return compare_3way(**this, rhs);
} else {
return strong_ordering::less;
}
}
constexpr strong_ordering operator<=>(nullopt_t ) const {
return has_value() ? strong_ordering::greater
: strong_ordering::equal;
}
};

La comparación bool 3 vías produce std::strong_ordering , que se puede convertir implícitamente a las otras cuatro categorías de comparación.

Del mismo modo, strong_ordering::less se convierte de forma implícita en weak_ordering::less , partial_ordering::less , strong_equality::unequal , o weak_equality::nonequivalent , según corresponda.