10 Classes [class]

10.10 Comparisons [class.compare]

10.10.2 Three-way comparison [class.spaceship]

The direct base class subobjects of C, in the order of their declaration in the base-specifier-list of C, followed by the non-static data members of C, in the order of their declaration in the member-specification of C, form a list of subobjects.

In that list, any subobject of array type is recursively expanded to the sequence of its elements, in the order of increasing subscript.

Let x

_{i}

be an lvalue denoting the

i^{th}

element in the expanded list of subobjects for an object x (of length n), where x

_{i}

is formed by a sequence of derived-to-base conversions ([over.best.ics]), class member access expressions ([expr.ref]), and array subscript expressions ([expr.sub]) applied to x.

The type of the expression x

_{i}

<=> x

_{i}

is denoted by R

_{i}

It is unspecified whether virtual base class subobjects are compared more than once.

If the declared return type of a defaulted three-way comparison operator function is auto, then the return type is deduced as the common comparison type (see below) of R

_{0}

, R

_{1}

, …, R

_{n - 1}

[ Note

Otherwise, the program will be ill-formed if the expression x

_{i}

<=> x

_{i}

is not implicitly convertible to the declared return type for any i.

— end note

]

If the return type is deduced as void, the operator function is defined as deleted.

The return value V of type R of the defaulted three-way comparison operator function with parameters x and y of the same type is determined by comparing corresponding elements x

_{i}

and y

_{i}

in the expanded lists of subobjects for x and y until the first index i where x

_{i}

<=> y

_{i}

yields a result value v

_{i}

where v

_{i}!= 0

, contextually converted to bool, yields true; V is v

_{i}

converted to R.

If no such index exists, V is std::strong_ordering::equal converted to R.

The common comparison type U of a possibly-empty list of n types T

_{0}

, T

_{1}

, …, T

_{n - 1}

is defined as follows:

(4.1)
If any T $_{i}$ is not a comparison category type ([cmp.categories]), U is void.
(4.2)
Otherwise, if at least one T $_{i}$ is std::weak_equality, or at least one T $_{i}$ is std::strong_equality and at least one T $_{j}$ is std::partial_ordering or std::weak_ordering, U is std::weak_equality ([cmp.weakeq]).
(4.3)
Otherwise, if at least one T $_{i}$ is std::strong_equality, U is std::strong_equality ([cmp.strongeq]).
(4.4)
Otherwise, if at least one T $_{i}$ is std::partial_ordering, U is std::partial_ordering ([cmp.partialord]).
(4.5)
Otherwise, if at least one T $_{i}$ is std::weak_ordering, U is std::weak_ordering ([cmp.weakord]).
(4.6)
Otherwise, U is std::strong_ordering ([cmp.strongord]).

[ Note
:
In particular, this is the result when n is 0.
— end note
]