C++ Three-Way Comparison Operator vs Subtraction – Differences

c++c++20comparison-operatorsspaceship-operator

There's a new comparison operator <=> in C++20. However I think in most cases a simple subtraction works well:

int my_strcmp(const char *a, const char *b) {
    while (*a == *b && *a != 0 && *b != 0) {
        a++, b++;
    }
    // Version 1
    return *a - *b;
    // Version 2
    return *a <=> *b;
    // Version 3
    return ((*a > *b) - (*a < *b));
}

They have the same effect. I can't really understand the difference.

Best Answer

The operator solves the problem with numeric overflow that you get with subtraction: if you subtract a large positive number from a negative that is close to INT_MIN, you get a number that cannot be represented as an int, thus causing undefined behavior.

Although version 3 is free from this problem, it utterly lacks readability: it would take some time to understand by someone who has never seen this trick before. <=> operator fixes the readability problem, too.

This is only one problem addressed by the new operator. Section 2.2.3 of Herb Sutter's Consistent comparison paper talks about the use of <=> with other data types of the language where subtraction may produce inconsistent results.

Related Solutions

C++ – Understanding the <=> (Spaceship) Operator in C++

This is called the three-way comparison operator.

According to the P0515 paper proposal:

There’s a new three-way comparison operator, <=>. The expression a <=> b returns an object that compares <0 if a < b, compares >0 if a > b, and compares ==0 if a and b are equal/equivalent.

To write all comparisons for your type, just write operator<=> that returns the appropriate category type:

Return an _ordering if your type naturally supports <, and we’ll efficiently generate <, >, <=, >=, ==, and !=; otherwise return an _equality, and we’ll efficiently generate == and !=.

Return strong if for your type a == b implies f(a) == f(b) (substitutability, where f reads only comparison-salient state accessible using the nonprivate const interface), otherwise return weak.

The cppreference says:

The three-way comparison operator expressions have the form
lhs <=> rhs   (1)  
The expression returns an object that

compares <0 if lhs < rhs

compares >0 if lhs > rhs

and compares ==0 if lhs and rhs are equal/equivalent.

C++ – Efficiency of the Three-Way Comparison Operator

Would define operator>(a,b) as a<=>b > 0 not lead to large overhead?

It would lead to some overhead. The magnitude of the overhead is relative, though - in situations when costs of running comparisons are negligible in relation to the rest of the program, reducing code duplication by implementing one operator instead of five may be an acceptable trade-off.

However, the proposal does not suggest removing other comparison operators in favor of <=>: if you want to overload other comparison operators, you are free to do it:

Be general: Don’t restrict what is inherent. Don’t arbitrarily restrict a complete set of uses. Avoid special cases and partial features. – For example, this paper supports all seven comparison operators and operations, including adding three-way comparison via <=>. It also supports all five major comparison categories, including partial orders.

Best Answer

Related Solutions

C++ – Understanding the <=> (Spaceship) Operator in C++

C++ – Efficiency of the Three-Way Comparison Operator

Related Question