[class.compare] (original) (raw)

11.10.1 Defaulted comparison operator functions [class.compare.default]

A defaulted comparison operator function ([over.binary]) shall be a non-template function that

Such a comparison operator function is termeda defaulted comparison operator function for class C.

Name lookups and access checks in the implicit definition ([dcl.fct.def.default]) of a comparison operator function are performed from a context equivalent to its function-body.

A definition of a comparison operator as defaulted that appears in a class shall be the first declaration of that function.

[Example 1: struct S;bool operator==(S, S) = default; struct S { friend bool operator==(S, const S&) = default; };enum E { };bool operator==(E, E) = default; — _end example_]

A defaulted <=> or == operator function for class C is defined as deleted if any non-static data member of C is of reference type orC has variant members ([class.union.anon]).

A binary operator expression a @ b isusableif either

If the member-specificationdoes not explicitly declare any member or friend named operator==, an == operator function is declared implicitly for each three-way comparison operator function defined as defaulted in the member-specification, with the same access and function-definition and in the same class scope as the respective three-way comparison operator function, except that the return type is replaced with bool and the declarator-id is replaced with operator==.

[Note 1:

Such an implicitly-declared == operator for a class Xis defined as defaulted in the definition of X and has the same parameter-declaration-clause and trailing requires-clause as the respective three-way comparison operator.

It is declared with friend, virtual, constexpr, or consteval if the three-way comparison operator function is so declared.

If the three-way comparison operator function has no noexcept-specifier, the implicitly-declared == operator function has an implicit exception specification ([except.spec]) that can differ from the implicit exception specification of the three-way comparison operator function.

— _end note_]

[Example 2: template<typename T> struct X { friend constexpr std::partial_ordering operator<=>(X, X) requires (sizeof(T) != 1) = default;[[nodiscard]] virtual std::strong_ordering operator<=>(const X&) const = default;}; — _end example_]

[Note 2:

The == operator function is declared implicitly even if the defaulted three-way comparison operator function is defined as deleted.

— _end note_]

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 be an lvalue denoting the element in the expanded list of subobjects for an object x(of length n), where 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.

11.10.2 Equality operator [class.eq]

A defaulted equality operator function ([over.binary]) shall have a declared return type bool.

A defaulted == operator function for a class Cis defined as deleted unless, for each in the expanded list of subobjects for an object x of type C,is usable ([class.compare.default]).

The return value of a defaulted == operator function with parameters x and y is determined by comparing corresponding elements and in the expanded lists of subobjects for x and y(in increasing index order) until the first index iwhere yields a result value which, when contextually converted to bool, yields false.

The return value is false if such an index exists and true otherwise.

[Example 1: struct D { int i;friend bool operator==(const D& x, const D& y) = default;}; — _end example_]

11.10.3 Three-way comparison [class.spaceship]

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

[Note 1:

A synthesized three-way comparison is 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 be the elements of the expanded list of subobjects for an object x of type C.

The return value of type Rof the defaulted three-way comparison operator function with parameters x and y of the same type is determined by comparing corresponding elements and 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 Rbetween and yields a result value where , contextually converted to bool, yields true.

The return value is a copy of if such an index exists andstatic_cast<R>(std​::​strong_ordering​::​equal) otherwise.

The common comparison type Uof a possibly-empty list of n comparison category types, , …, is defined as follows:

11.10.4 Secondary comparison operators [class.compare.secondary]

A secondary comparison operator is a relational operator ([expr.rel]) or the != operator.

A defaulted operator function ([over.binary]) for a secondary comparison operator @shall have a declared return type bool.

The operator function with parameters x and yis defined as deleted if

In any of the two overload resolutions above, the defaulted operator function is not considered as a candidate for the @ operator.

Otherwise, the operator function yields x @ y.

[Example 1: struct HasNoLessThan { };struct C { friend HasNoLessThan operator<=>(const C&, const C&);bool operator<(const C&) const = default; }; — _end example_]