Changes Between C++17 and C++20

There is no return statement, although function is marked as `int`

The primary purpose of this is reducing boilerplate code. For supporting comparisons one currently has to implement a large set if functions. One for each of <, >, <=, =>, != and ==. However many times the implementation of those 6 functions is similar. Thus lots of code to write.

With operator<=> one can implement a single function and the compiler becomes the smart one. When calling o1 < o2 or calling o1 >= o2 the compiler will do a call to the single operator<=> and interpret the return value accordingly.

Notably less repitive typing for the type provider.

One of the useful things added is that the language can now define a default <=> operator for your own classes, for example if you had struct Foo {int a; int b;} previously you'd have had to define your own comparison operators such as:

bool operator<(const Foo& foo) const { if (a < foo.a) return true; if (a > foo.a) return false; if (b < foo.b) return true; if (b > foo.b) return false; return false; }

.. and all the other comparison operators that you needed.

But now, you can just say:

auto operator<=>(const Foo&) const = default;

and the compiler will automatically generate all the operators for you.

I read that to mean that it saves you from writing highly redundant operator overloads for comparable classes.

You can think of two types of comparison:

* Those that return a boolean. eg. operator < returns bool, true if less than the operand, false if greater or equal.

* Those that return a 3-way value. An example of this would be strcmp(), which might return -1 if less, 0 if equal, and 1 if greater.

The insight is that if the compiler knows the latter exists, it can fill in the former category, and the programmer doesn't have to write a bunch of extra overloads.

One of the goals is to eliminate boilerplate. If I'm remembering my C++ correctly,!=, <=, >, and >= can be easily defined in terms of < and ==, but programmers were required to spell out the definitions for all the operators manually. With operator<=>, one definition would allow the compiler to generate all 6 operators.

There are some correctness and efficiency concerns operator<=> addresses, too, but I'm not confident I can explain those well.

You can read more in P0515R0 [0], which sort of "rolls up" previous papers discussing comparisons.

[0]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p051...