3-way comparison operator (Space Ship Operator) in C++ 20

In this article, we will discuss the 3-way comparison operator (Space Ship Operator) in C++ with its syntax and example.

What is a 3-way comparison operator (Space Ship Operator)?

"Spaceship Operator" or "Three-Way Comparison Operator", denoted by the <=> symbol. Using this operator, two values can be compared to get a result that shows how they relate to one another. Less than, equal to, or greater than are the possible outcomes.

Here's a detailed explanation of the three-way comparison operator in C++20:

Syntax:

It has the following syntax:

Return Values:

The outcome is negative if the left side (LHS) is smaller than the right side (RHS).
The outcome is zero if the LHS and RHS are equal.
The outcome is positive if the LHS exceeds the RHS.

Examples:

Let's take an example to illustrate the 3-way comparison operator in C++.

#include <iostream>
int main() {
int a = 5;
int b = 10;
auto result = a <=> b;
if (result < 0) {
std::cout << "a is less than b\n";
} else if (result == 0) {
std::cout << "a is equal to b\n";
} else {
std::cout << "a is greater than b\n";
}
return 0;
}

Output:

3-way comparison operator (Space Ship Operator) in C++ 20

Explanation:

As an illustration, the outcome of the comparison a <=> b is kept in the variable result and subsequently examined to ascertain the connection between a and b.

Overloading the Spaceship Operator:

An additional way to overload the spaceship operator for user-defined types is to supply operator<=>: as a member function.

Examples:

Let's take an example to illustrate the 3-way comparison operator using overloading the spaceship operator in C++.

#include <iostream>
class MyClass {
public:
int value;
MyClass(int val) : value(val) {}
auto operator<=>(const MyClass& other) const {
return value <=> other.value;
}
};
int main() {
MyClass obj1(5);
MyClass obj2(10);
auto result = obj1 <=> obj2;
if (result < 0) {
std::cout << "obj1 is less than obj2\n";
} else if (result == 0) {
std::cout << "obj1 is equal to obj2\n";
} else {
std::cout << "obj1 is greater than obj2\n";
}
return 0;
}

Output:

Explanation:

In this example, we can use the three-way comparison operator with objects of this class because the operator<=> member function is defined for the MyClass type.

Benefits of 3-way comparison operator (Space Ship Operator) in C++ 20

Adding the "Spaceship Operator", or three-way comparison operator, to C++20 improves the language in several ways. The following are some of the main benefits:

Readability and Conciseness:

The three-way comparison operator facilitates code simplification by offering a brief means of expressing comparisons. You can use a single operator (\=>) for comparisons of more significant than, equal to, and less than instead of writing separate code for each comparison to improve code readability.

Code with Less Boilerplate:

When working with user-defined types before C++20, developers frequently had to write boilerplate code for custom comparison operators or functions. The three-way comparison operator removes much of this boilerplate, resulting in a more condensed and manageable piece of code.

Standardized Comparison Semantics:

The three-way comparison operator introduces a standardized method for conducting comparisons. This consistency helps prevent errors and confusion in code because developers can rely on a standard syntax and behaviour for comparisons across different types.

Algorithms and Ranges Supported:

The three-way comparison operator makes it easier to use algorithms that depend on comparisons and is consistent with the ideas of the C++20 Ranges library. For instance, algorithms for sorting and searching can benefit from the operator's three possible outcomes.

Typical Comparing Functions:

C++20 introduced defaulted comparison functions (==,!=, \, \=, >, >=) along with the spaceship operator. The compiler can use the spaceship operator to generate these functions automatically, negating the need to manually implement these functions in user-defined types.

Increased Type Safety:

The three-way comparison operator increases type safety by encouraging a standardized comparison syntax. It can strengthen the code's robustness and stop comparison operators from being accidentally misused.

Opportunities for Performance Optimization:

It is possible to optimize performance by using the three-way comparison operator. When the compiler can take advantage of its knowledge of the underlying types and their comparison properties, it can produce more efficient code due to standardized comparisons.

Simplified Code Review and Upkeep:

Three-way comparison operator-based code is typically more expressive and self-explanatory. It can lessen the cognitive load when maintaining or changing code and simplify code reviews.

Conclusion:

It's crucial to remember that even though the three-way comparison operator has these advantages, its impact and adoption depend on each project's particular use cases and coding standards. As usual, developers should consider their project's requirements and context when determining whether to use this operator.

Next TopicAlgorithmic Trading with C++

← prev next →