11 Classes [class]

11.11 Comparisons [class.compare]

11.11.3 Three-way comparison [class.spaceship]

The synthesized three-way comparison of type R ([cmp.categories]) of glvalues a and b of the same type is defined as follows:

(1.1)
If a <=> b is usable ([class.compare.default]), static_cast<R>(a <=> b).
(1.2)
Otherwise, if overload resolution for a <=> b is performed and finds at least one viable candidate, the synthesized three-way comparison is not defined.
(1.3)
Otherwise, if R is not a comparison category type, or either the expression a == b or the expression a < b is not usable, the synthesized three-way comparison is not defined.

(1.4)

Otherwise, if R is strong_ordering, then

a == b ? strong_ordering::equal :
a < b  ? strong_ordering::less :
         strong_ordering::greater

(1.5)

Otherwise, if R is weak_ordering, then

a == b ? weak_ordering::equivalent :
a < b  ? weak_ordering::less :
         weak_ordering::greater

(1.6)

Otherwise (when R is partial_ordering),

a == b ? partial_ordering::equivalent :
a < b  ? partial_ordering::less :
b < a  ? partial_ordering::greater :
         partial_ordering::unordered

[ Note

A synthesized three-way comparison may be ill-formed if overload resolution finds usable candidates that do not otherwise meet the requirements implied by the defined expression.

— end note

]

Let R be the declared return type of a defaulted three-way comparison operator function, and let

x_{i}

be the elements of the expanded list of subobjects for an object x of type C.

(2.1)
If R is auto, then let $c v_{i} R_{i}$ be the type of the expression $x_{i} <=> x_{i}$ .

The operator function is defined as deleted if that expression is not usable or if $R_{i}$ is not a comparison category type ([cmp.categories.pre]) for any i.

The return type is deduced as the common comparison type (see below) of $R_{0}$ , $R_{1}$ , …, $R_{n - 1}$ .
(2.2)
Otherwise, R shall not contain a placeholder type.

If the synthesized three-way comparison of type R between any objects $x_{i}$ and $x_{i}$ is not defined, 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 (in increasing index order) until the first index i where the synthesized three-way comparison of type R between

x_{i}

and

y_{i}

yields a result value

v_{i}

where

v_{i}!= 0

, contextually converted to bool, yields true; V is a copy of

v_{i}

If no such index exists, V is static_cast<R>(std::strong_ordering::equal).

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

T_{0}

T_{1}

, …,

T_{n - 1}

is defined as follows:

(4.1)
If at least one $T_{i}$ is std::partial_ordering, U is std::partial_ordering ([cmp.partialord]).
(4.2)
Otherwise, if at least one $T_{i}$ is std::weak_ordering, U is std::weak_ordering ([cmp.weakord]).
(4.3)
Otherwise, U is std::strong_ordering ([cmp.strongord]).

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