Why Does a Custom Spaceship Operator in C 20 Prevent Automatic Equality Comparison?

The Spaceship Operator and Equality Comparison

The C 20 spaceship operator (also known as <=>) introduces convenient and concise syntax for comparing values. However, in certain scenarios, it may not generate the expected equality and inequality operators (== and !=). This question explores this behavior and why a custom spaceship operator implementation can prevent the creation of these additional operators.

Problem Description

Consider the following code snippet where the spaceship operator is used in a struct with a default implementation:

struct X
{
    int Dummy = 0;
    auto operator<=>(const X& other) const = default; // Default implementation
};

This code compiles without errors. However, if we define a custom spaceship operator implementation:

struct X
{
    int Dummy = 0;
    auto operator<=>(const X& other) const
    {
        return Dummy <=> other.Dummy;
    }
};

The compiler will issue an error when attempting to use the equality operator (==):

error C2676: binary '==': 'X' does not define this operator or a conversion to a type acceptable to the predefined operator

Explanation

This behavior is intentional, as defined by the language standard. When a class has a defaulted spaceship operator, the compiler synthesizes a default implementation of the equality operator. However, if the spaceship operator is implemented with a custom definition, the compiler does not generate the equality operator automatically.

This distinction stems from concerns about efficiency. The spaceship operator is designed to provide a complete ordering of values, while the equality operator (==) may perform optimizations, such as comparing sizes before attempting a full comparison. For classes like std::vector, using the spaceship operator for equality comparisons may not be the most efficient approach.

By leaving it to the programmer to implement the equality operator, the compiler avoids the potential for generating a non-optimal implementation. Thus, if a class has a non-defaulted spaceship operator, the developer must explicitly define the equality operator as well.

The above is the detailed content of Why Does a Custom Spaceship Operator in C 20 Prevent Automatic Equality Comparison?. For more information, please follow other related articles on the PHP Chinese website!