{"id":5927,"date":"2020-06-16T13:46:07","date_gmt":"2020-06-16T13:46:07","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-20-more-details-to-the-spaceship-operator\/"},"modified":"2023-06-26T09:48:50","modified_gmt":"2023-06-26T09:48:50","slug":"c-20-more-details-to-the-spaceship-operator","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-20-more-details-to-the-spaceship-operator\/","title":{"rendered":"C++20: More Details to the Spaceship Operator"},"content":{"rendered":"

The compiler performs cleverly when it generates all six comparison operators. Ultimately, you get intuitive and efficient comparison operators for free. Let me dive into this post into the details of the spaceship operator.<\/p>\n

<\/p>\n

 \"TimelineCpp20\"<\/p>\n

First, I want to add something I should have written about in my first post to the three-way comparison operator: “C++20: The Three-Way Comparision Operator<\/a>“.<\/p>\n

Direct Usage of the Three-Way Comparison Operator<\/h2>\n

You can directly use the spaceship operator:<\/p>\n

 <\/p>\n

<\/p>\n

\n
\/\/ spaceship.cpp<\/span>\r\n\r\n#include <compare><\/span>\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <vector><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n    int<\/span> a(2011<\/span>);\r\n    int<\/span> b(2014<\/span>);\r\n    auto<\/span> res =<\/span> a <=><\/span> b;                 \/\/ (1)<\/span>\r\n    if<\/span> (res <<\/span> 0<\/span>) std::<\/span>cout <<<\/span> \"a < b\"<\/span> <<<\/span> std::<\/span>endl;\r\n    else<\/span> if<\/span> (res ==<\/span> 0<\/span>) std::<\/span>cout <<<\/span> \"a == b\"<\/span> <<<\/span> std::<\/span>endl;\r\n    else<\/span> if<\/span> (res ><\/span> 0<\/span>) std::<\/span>cout <<<\/span> \"a > b\"<\/span> <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>string str1(\"2014\"<\/span>);\r\n    std::<\/span>string str2(\"2011\"<\/span>);\r\n    auto<\/span> res2 =<\/span> str1 <=><\/span> str2;          \/\/ (2)<\/span>\r\n    if<\/span> (res2 <<\/span> 0<\/span>) std::<\/span>cout <<<\/span> \"str1 < str2\"<\/span> <<<\/span> std::<\/span>endl;\r\n    else<\/span> if<\/span> (res2 ==<\/span> 0<\/span>) std::<\/span>cout <<<\/span> \"str1 == str2\"<\/span> <<<\/span> std::<\/span>endl;\r\n    else<\/span> if<\/span> (res2 ><\/span> 0<\/span>) std::<\/span>cout <<<\/span> \"str1 > str2\"<\/span> <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>vector<<\/span>int<\/span>><\/span> vec1{1<\/span>, 2<\/span>, 3<\/span>};\r\n    std::<\/span>vector<<\/span>int<\/span>><\/span> vec2{1<\/span>, 2<\/span>, 3<\/span>};\r\n    auto<\/span> res3 =<\/span> vec1 <=><\/span> vec2;          \/\/ (3)<\/span>\r\n    if<\/span> (res3 <<\/span> 0<\/span>) std::<\/span>cout <<<\/span> \"vec1 < vec2\"<\/span> <<<\/span> std::<\/span>endl;\r\n    else<\/span> if<\/span> (res3 ==<\/span> 0<\/span>) std::<\/span>cout <<<\/span> \"vec1 == vec2\"<\/span> <<<\/span> std::<\/span>endl;\r\n    else<\/span> if<\/span> (res3 ><\/span> 0<\/span>) std::<\/span>cout <<<\/span> \"vec1 > vec2\"<\/span> <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
You can directly use the spaceship operator for int<\/span>‘s (1), string<\/span>‘s (2), and vecto<\/span>r’s (3). Thanks to the wandbox online-compiler <\/a>and the newest GCC, here is the program’s output.<\/p>\n
\"spaceship\"<\/p>\n
Now, it’s time for something new in C++. C++20 introduces the concept of “rewritten” expressions.<\/p>\n<\/p>\n
Rewriting Expressions<\/h2>\n
When the compiler sees something such as a < b,<\/span> it rewrites it to (a <=> b) < 0 <\/span>using the spaceship operator. <\/span><\/p>\n
Of course, the rule applies to all six comparison operators:<\/p>\n
a OP<\/span> b<\/strong> becomes (a <=> b) OP 0<\/span><\/strong>. It’s even better. If there is no conversion of the type(a)<\/span> to the type(b)<\/span>, the compiler generates the new expression 0 OP (b <=> a)<\/span><\/strong>.<\/p>\n
For example, this means for the less-than operator, if (a <=> b) < 0<\/span><\/strong> does not work, the compiler generates 0 < (b <=> a)<\/span><\/strong>. In essence, the compiler automatically takes care of the symmetry of the comparison operators. <\/span><\/p>\n
Here are a few examples of the rewriting expressions:<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ rewrittenExpressions.cpp<\/span>\r\n\r\n#include <compare><\/span>\r\n#include <iostream><\/span>\r\n\r\nclass<\/span> MyInt<\/span> {\r\n public:<\/span>\r\n    constexpr MyInt(int<\/span> val):<\/span> value{val} { }\r\n    auto<\/span> operator<\/span><=><\/span>(const<\/span> MyInt&<\/span> rhs) const<\/span> =<\/span> default<\/span>;  \r\n private<\/span>:<\/span>\r\n    int<\/span> value;\r\n};\r\n\r\nint<\/span> main<\/span>() {\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n    constexpr MyInt myInt2011(2011<\/span>);\r\n    constexpr MyInt myInt2014(2014<\/span>);\r\n   \r\n    constexpr int<\/span> int2011(2011<\/span>);\r\n    constexpr int<\/span> int2014(2014<\/span>);\r\n    \r\n    if<\/span> (myInt2011 <<\/span> myInt2014) std::<\/span>cout <<<\/span> \"myInt2011 < myInt2014\"<\/span> <<<\/span> std::<\/span>endl;          \/\/ (1)<\/span>\r\n    if<\/span> ((myInt2011 <=><\/span> myInt2014) <<\/span> 0<\/span>) std::<\/span>cout <<<\/span> \"myInt2011 < myInt2014\"<\/span> <<<\/span> std::<\/span>endl; \r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n    if<\/span> (myInt2011 <<\/span> int2014) std::<\/span> cout <<<\/span> \"myInt2011 < int2014\"<\/span> <<<\/span> std::<\/span>endl;             \/\/ (2)<\/span>\r\n    if<\/span> ((myInt2011 <=><\/span> int2014) <<\/span> 0<\/span>) std::<\/span> cout <<<\/span> \"myInt2011 < int2014\"<\/span> <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n    if<\/span> (int2011 <<\/span> myInt2014) std::<\/span>cout <<<\/span> \"int2011 < myInt2014\"<\/span> <<<\/span> std::<\/span>endl;              \/\/ (3)<\/span>\r\n    if<\/span> (0<\/span> <<\/span> (myInt2014 <=><\/span> int2011)) std::<\/span> cout <<<\/span> \"int2011 < myInt2014\"<\/span> <<<\/span> std::<\/span>endl;     \/\/ (4)<\/span>\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n   \r\n<\/pre>\n<\/div>\n
 <\/p>\n
I used in (1), (2), and (3) the less-than operator and the corresponding spaceship expression. (4) is the most exciting example. It exemplifies how the comparison (int2011 < myInt2014<\/span>) triggers the generation of the spaceship expression (0 < (myInt2014 <=> int2011<\/span>).<\/p>\n
MyInt<\/span> has an issue.  Constructors taking one argument should be explicit.<\/p>\n
Explicit Constructor<\/h2>\n
Constructors taking one argument, such as MyInt(int val)<\/span> are conversion constructors. In the concrete case, an instance from MyInt<\/span> can be generated from any integral or floating-point value because each integral or floating-point value can implicitly be converted to int<\/span>. I assume you don’t want implicit conversion from an integral or a floating-point value when an instance of MyInt<\/span> is required.<\/span><\/span><\/p>\n
First Try<\/h3>\n
To disable this implicit conversion, I make the constructor explicit following the Python meta-rule: explicit is better than implicit. The following program shows the explicit constructor:<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ threeWayComparisonWithInt1.cpp<\/span>\r\n\r\n#include <compare><\/span>\r\n#include <iostream><\/span>\r\n\r\nclass<\/span> MyInt<\/span> {\r\n public:<\/span>\r\n    constexpr explicit<\/span> MyInt(int<\/span> val):<\/span> value{val} { }\r\n    auto<\/span> operator<\/span><=><\/span>(const<\/span> MyInt&<\/span> rhs) const<\/span> =<\/span> default<\/span>;  \r\n private<\/span>:<\/span>\r\n    int<\/span> value;\r\n};\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span>\r\nconstexpr bool<\/span> isLessThan(const<\/span> T&<\/span> lhs, const<\/span> T2&<\/span> rhs) {\r\n    return<\/span> lhs <<\/span> rhs;                                          \/\/ (1)<\/span>\r\n}\r\n\r\nint<\/span> main() {\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> std::<\/span>endl;\r\n    \r\n    constexpr MyInt myInt2011<\/span>(2011<\/span>);\r\n    constexpr MyInt myInt2014<\/span>(2014<\/span>);\r\n    \r\n    constexpr int<\/span> int2011<\/span>(2011<\/span>);\r\n    constexpr int<\/span> int2014<\/span>(2014<\/span>);\r\n    \r\n    std::<\/span>cout <<<\/span> \"isLessThan(myInt2011, myInt2014): \"<\/span>\r\n              <<<\/span> isLessThan(myInt2011, myInt2014) <<<\/span> std::<\/span>endl;\r\n              \r\n    std::<\/span>cout <<<\/span> \"isLessThan(int2011, myInt2014): \"<\/span>\r\n              <<<\/span> isLessThan(int2011, myInt2014) <<<\/span> std::<\/span>endl;  \/\/ (3)<\/span>\r\n            \r\n    std::<\/span>cout <<<\/span> \"isLessThan(myInt2011, int2014): \"<\/span>\r\n              <<<\/span> isLessThan(myInt2011, int2014) <<<\/span> std::<\/span>endl;  \/\/ (2)<\/span>\r\n              \r\n    constexpr auto<\/span> res =<\/span> isLessThan(myInt2011, int2014);\r\n              \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n              \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
This was easy. Thanks to the explicit constructor, the implicit conversion from int to MyInt i<\/span>n (1) is not valid anymore. The compiler now speaks an unambiguous message.<\/p>\n
\"threeWayComparisonWithInt1\"<\/p>\n
When you read the error message carefully, you notice that there is no operator < for a right-hand operand int available and no conversion from int<\/span> to MyIn<\/span>t possible. Interestingly, the compiler complains about (2) but not about (3). Both function calls cause a compiler error.<\/p>\n
Second Try<\/h3>\n
To support the comparison from MyInt<\/span>‘s and int<\/span>‘s, MyInt<\/span> needs an additional three-way comparison operator.<\/p>\n
 <\/p>\n
<\/p>\n
\n
#include <compare><\/span>\r\n#include <iostream><\/span>\r\n\r\nclass<\/span> MyInt<\/span> {\r\n public:<\/span>\r\n    constexpr explicit<\/span> MyInt(int<\/span> val):<\/span> value{val} { }\r\n    auto<\/span> operator<\/span><=><\/span>(const<\/span> MyInt&<\/span> rhs) const<\/span> =<\/span> default<\/span>; \/\/ (4)<\/span> \r\n    constexpr auto<\/span> operator<\/span><=><\/span>(const<\/span> int<\/span>&<\/span> rhs) const<\/span> {  \/\/ (1)<\/span>\r\n        return<\/span> value <=><\/span> rhs;\r\n    }\r\n private:<\/span> \r\n    int<\/span> value;\r\n};\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span>\r\nconstexpr bool<\/span> isLessThan(const<\/span> T&<\/span> lhs, const<\/span> T2&<\/span> rhs) {\r\n    return<\/span> lhs <<\/span> rhs;\r\n}\r\n\r\nint<\/span> main() {\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> std::<\/span>endl;\r\n    \r\n    constexpr MyInt myInt2011<\/span>(2011<\/span>);\r\n    constexpr MyInt myInt2014<\/span>(2014<\/span>);\r\n    \r\n    constexpr int<\/span> int2011<\/span>(2011<\/span>);\r\n    constexpr int<\/span> int2014<\/span>(2014<\/span>);\r\n    \r\n    std::<\/span>cout <<<\/span> \"isLessThan(myInt2011, myInt2014): \"<\/span>\r\n              <<<\/span> isLessThan(myInt2011, myInt2014) <<<\/span> std::<\/span>endl; \/\/ (3)<\/span> \r\n              \r\n    std::<\/span>cout <<<\/span> \"isLessThan(int2011, myInt2014): \"<\/span>\r\n              <<<\/span> isLessThan(int2011, myInt2014) <<<\/span> std::<\/span>endl;   \/\/ (3)<\/span>\r\n            \r\n    std::<\/span>cout <<<\/span> \"isLessThan(myInt2011, int2014): \"<\/span>\r\n              <<<\/span> isLessThan(myInt2011, int2014) <<<\/span> std::<\/span>endl;   \/\/ (3)<\/span>\r\n              \r\n    constexpr auto<\/span> res =<\/span> isLessThan(myInt2011, int2014);        \/\/ (2)<\/span>\r\n              \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n              \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I defined in (1) the three-way comparison operator and declared it constexpr<\/span>. The user-defined three-way comparison operator is in contrast to the compiler-generated three-way comparison operator, not constexpr<\/span>. Consequently, I can perform the isLessThan<\/span> (4) call at compile-time. Comparing MyInt’<\/span>s and int’<\/span>s is possible in each combination (3).<\/p>\n
\"threeWayComparisonWithInt2\"<\/p>\n
 <\/p>\n
I find the implementation of the various three-way comparison operators very elegant. The compiler auto-generates the comparison of MyInt’<\/span>s, and the user defines the comparison with int<\/span>‘s explicitly.  Additionally, you have to define only two operators to get 18 = 3 * 6 combinations of comparison operators. 3 represents the combination of int<\/span>‘s and MyInt<\/span>‘s and 6 for the six comparison operators. I discussed in my last post, “C++20: The Three-Way Comparision Operator<\/a>”  the 18 operators you had to overload before C++20.<\/p>\n
I want to make one point clear: You can even compare MyInt<\/span> which each type that is convertible to int<\/span>.<\/p>\n
Stop!<\/strong> You may ask yourself: What is the current implementation using an explicit constructor<\/p>\n
<\/p>\n
\n
<\/span>class<\/span> MyInt<\/span> {\r\n public:<\/span>\r\n    constexpr explicit<\/span> MyInt(int<\/span> val):<\/span> value{val} { }\r\n    auto<\/span> operator<\/span><=><\/span>(const<\/span> MyInt&<\/span> rhs) const<\/span> =<\/span> default<\/span>; <\/span>\r\n    constexpr auto<\/span> operator<\/span><=><\/span>(const<\/span> int<\/span>&<\/span> rhs) const<\/span> {  <\/span>\r\n        return<\/span> value <=><\/span> rhs;\r\n    }\r\n private:<\/span> \r\n    int<\/span> value;\r\n};\r\n<\/pre>\n<\/div>\n
 <\/p>\n
better than the previous implementation using a constructor capable of implicit conversions? Both classes allow comparisons with integrals and floating-point values.<\/p>\n
<\/p>\n
\n
<\/span>class<\/span> MyInt<\/span> {\r\n public:<\/span>\r\n    constexpr MyInt(int<\/span> val):<\/span> value{val} { }\r\n    auto<\/span> operator<\/span><=><\/span>(const<\/span> MyInt&<\/span> rhs) const<\/span> =<\/span> default<\/span>;  \r\n private<\/span>:<\/span>\r\n    int<\/span> value;\r\n};W\r\n<\/pre>\n<\/div>\n
 <\/p>\n
What’s next?<\/h2>\n
There is a subtle difference between an explicit and a non-explicit constructor for MyInt<\/span> that you can easily see when I make MyInt<\/span> more int<\/span>-like in my next post.<\/a> <\/span>Additionally, the compiler-generated ==<\/span> and !=<\/span> operators are special for performance reasons, and the interplay of classical comparison operators and the three-way comparison operator are worth an extra post.<\/p>\n
 <\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
The compiler performs cleverly when it generates all six comparison operators. Ultimately, you get intuitive and efficient comparison operators for free. Let me dive into this post into the details of the spaceship operator.<\/p>\n","protected":false},"author":21,"featured_media":5199,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[462],"class_list":["post-5927","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20","tag-spaceship"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5927","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5927"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5927\/revisions"}],"predecessor-version":[{"id":6737,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5927\/revisions\/6737"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5199"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5927"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5927"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5927"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}