Otherwise, if the operands have integral type,
the result is of type std::strong_ordering.
The result is
if both operands are arithmetically equal,
if the first operand is arithmetically
less than the second operand,
Otherwise, the operands have floating-point type, and
the result is of type std::partial_ordering.
The expression a <=> b yields
if a is less than b,
if a is greater than b,
if a is equivalent to b,
If at least one of the operands is of pointer type and
the other operand is of pointer or array type,
array-to-pointer conversions ([conv.array]),
pointer conversions ([conv.ptr]),
are performed on both operands
to bring them to their composite pointer type ([expr.type]).
After the conversions, the operands shall have the same type.
If the composite pointer type is an object pointer type,
p <=> q is of type std::strong_ordering.
If two pointer operands p and q compare equal ([expr.eq]),
p <=> q yields std::strong_ordering::equal;
if p and q compare unequal,
p <=> q yields
if q compares greater than p
if p compares greater than q ([expr.rel]).
The three comparison category types ([cmp.categories])
are not predefined;
if the header <compare> ([compare.syn])
is not imported or included prior to a use of such a class type –
even an implicit use in which the type is not named
(e.g., via the auto specifier
in a defaulted three-way comparison
or use of the built-in operator) – the program is ill-formed.