{"id":8844,"date":"2024-01-08T09:56:01","date_gmt":"2024-01-08T09:56:01","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=8844"},"modified":"2024-01-08T09:56:01","modified_gmt":"2024-01-08T09:56:01","slug":"the-autogenerated-equality-operator","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/the-autogenerated-equality-operator\/","title":{"rendered":"The autogenerated Equality Operator"},"content":{"rendered":"\n

You can define the three-way comparison operator or request it from the compiler with =default<\/code>. But do you know that you can also define or request the equality operator in C++20?<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

Before I dive into the autogenerated equality operator, I’d like to refresh your knowledge about the three-way comparison operator.<\/p>\n\n\n\n

The Three-Way Comparison Operator<\/h2>\n\n\n\n

You can define the three-way comparison operator or request it from the compiler with =default<\/code>. You get all six comparison operators in both cases: ==, !=, <, <=, >,<\/code> and >=<\/code>.<\/p>\n\n\n\n

\/\/ threeWayComparison.cpp<\/span>\n\n#include <compare><\/span>\n#include <iostream><\/span>\n\nstruct<\/span> MyInt {\n    int<\/span> value;\n    explicit<\/span> MyInt(int<\/span> val):<\/span> value{val} { }\n    auto<\/span> operator<\/span><=><\/span>(const<\/span> MyInt&<\/span> rhs) const<\/span> {           \/\/ (1)      <\/span>\n        return<\/span> value <=><\/span> rhs.value;\n    }\n};\n\nstruct<\/span> MyDouble {\n    double<\/span> value;\n    explicit<\/span> constexpr MyDouble(double<\/span> val):<\/span> value{val} { }\n    auto<\/span> operator<\/span><=><\/span>(const<\/span> MyDouble&<\/span>) const<\/span> =<\/span> default<\/span>;   \/\/ (2)<\/span>\n};\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\nconstexpr bool<\/span> isLessThan(const<\/span> T&<\/span> lhs, const<\/span> T&<\/span> rhs) {\n    return<\/span> lhs <<\/span> rhs;\n}\n\nint<\/span> main() {\n    \n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> std::<\/span>endl;\n    \n    MyInt myInt1<\/span>(2011<\/span>);\n    MyInt myInt2<\/span>(2014<\/span>);\n    \n    std::<\/span>cout <<<\/span> "isLessThan(myInt1, myInt2): "<\/span>\n              <<<\/span> isLessThan(myInt1, myInt2) <<<\/span> std::<\/span>endl;\n              \n    MyDouble myDouble1<\/span>(2011<\/span>);\n    MyDouble myDouble2<\/span>(2014<\/span>);\n    \n    std::<\/span>cout <<<\/span> "isLessThan(myDouble1, myDouble2): "<\/span>\n              <<<\/span> isLessThan(myDouble1, myDouble2) <<<\/span> std::<\/span>endl;          \n              \n    std::<\/span>cout <<<\/span> std::<\/span>endl;\n              \n}\n<\/pre><\/div>\n\n\n\n
The user-defined (1) and the compiler-generated (2) three-way comparison operators work as expected.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
But there are a few subtle differences in this case. The compiler-deduced return type for MyInt <\/code>(1) supports strong ordering, and the compiler-deduced return type of MyDouble<\/code> supports partial ordering. Floating pointer numbers only support partial ordering because floating-point values such as NaN<\/a> (Not a Number) can not be ordered. For example, NaN == NaN<\/code>  is false<\/code>.<\/p>\n\n\n\n
The compiler-generated three-way comparison operator needs the header <compare><\/code>, which is implicit constexpr<\/code> and noexcept<\/code>. Additionally, it performs a lexicographical comparison. Lexicographical comparison means that all base classes are compared left to right and all non-static members in their declaration order.<\/p>\n\n\n\n
Let’s assume I add a std::unordered_set <\/code>to both classes MyInt<\/code> and MyDouble<\/code>. <\/p>\n\n\n\n
struct<\/span> MyInt {\n    int<\/span> value;\n    std::<\/span>unordered_set<<\/span>int<\/span>><\/span> mySet;\n    explicit<\/span> MyInt(int<\/span> val):<\/span> value{val}, mySet{val} { }\n    bool<\/span> operator<\/span><=><\/span>(const<\/span> MyInt&<\/span> rhs) const<\/span> {\n        if<\/span> (auto<\/span> first =<\/span> value <=><\/span> rhs.value; first !=<\/span> 0<\/span>) return<\/span> first;\n        else<\/span> return<\/span> mySet <=><\/span> rhs.mySet; \n    }\n};\n\nstruct<\/span> MyDouble {\n    double<\/span> value;\n    std::<\/span>unordered_set<<\/span>double<\/span>><\/span> mySet;\n    explicit<\/span> MyDouble(double<\/span> val):<\/span> value{val}, mySet{val} { }\n    bool<\/span> operator<\/span><=><\/span>(const<\/span> MyDouble&<\/span>) const<\/span> =<\/span> default<\/span>;   \n};\n<\/pre><\/div>\n\n\n\n
Requesting or defining the three-way comparison fails because std::unordered_set<\/code> does not support ordering. std::unordered_set<\/code> only support equality comparison, and so does MyInt<\/code> and MyDouble<\/code>.<\/p>\n\n\n\n
Equality Operator<\/h2>\n\n\n\n
When you define or request the equality operator from the compiler with =default<\/code>, you automatically
get the equality and inequality operators: ==<\/code>, and !=<\/code>.<\/p>\n\n\n\n
\/\/ equalityOperator.cpp<\/span>\n\n#include <iostream><\/span>\n#include <tuple><\/span>\n#include <unordered_set><\/span>\n\nstruct<\/span> MyInt {\n    int<\/span> value;\n    std::<\/span>unordered_set<<\/span>int<\/span>><\/span> mySet;\n    explicit<\/span> MyInt<\/span>(int<\/span> val):<\/span> value{val}, mySet{val} { }\n    bool<\/span> operator<\/span>==<\/span>(const<\/span> MyInt&<\/span> rhs) const<\/span> {                 \n        return<\/span> std::<\/span>tie(value, mySet) ==<\/span> std::<\/span>tie(rhs.value, rhs.mySet);\n    }\n};\n\nstruct<\/span> MyDouble {\n    double<\/span> value;\n    std::<\/span>unordered_set<<\/span>double<\/span>><\/span> mySet;\n    explicit<\/span> MyDouble(double<\/span> val):<\/span> value{val}, mySet{val} { }\n    bool<\/span> operator<\/span>==<\/span>(const<\/span> MyDouble&<\/span>) const<\/span> =<\/span> default<\/span>;   \n};\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\nconstexpr bool<\/span> areEqual(const<\/span> T&<\/span> lhs, const<\/span> T&<\/span> rhs) {\n\n    return<\/span> lhs ==<\/span> rhs;\n}\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\nconstexpr bool<\/span> areNotEqual(const<\/span> T&<\/span> lhs, const<\/span> T&<\/span> rhs) {\n\n    return<\/span> lhs !=<\/span> rhs;\n}\n\nint<\/span> main() {\n    \n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> '\\n'<\/span>;\n    \n    MyInt myInt1<\/span>(2011<\/span>);\n    MyInt myInt2<\/span>(2014<\/span>);\n    \n    std::<\/span>cout <<<\/span> "areEqual(myInt1, myInt2): "<\/span>\n              <<<\/span> areEqual(myInt1, myInt2) <<<\/span> '\\n'<\/span>;\n    std::<\/span>cout <<<\/span> "areNotEqual(myInt1, myInt2): "<\/span>\n              <<<\/span> areNotEqual(myInt1, myInt2) <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;          \n              \n    MyDouble myDouble1<\/span>(2011.0<\/span>);\n    MyDouble myDouble2<\/span>(2014.0<\/span>);\n    \n    std::<\/span>cout <<<\/span> "areEqual(myDouble1, myDouble2): "<\/span>\n              <<<\/span> areEqual(myDouble1, myDouble2) <<<\/span> '\\n'<\/span>;\n    std::<\/span>cout <<<\/span> "areNotEqual(myDouble1, myDouble2): "<\/span>\n              <<<\/span> areNotEqual(myDouble1, myDouble2) <<<\/span> '\\n'<\/span>;           \n              \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n              \n}\n<\/pre><\/div>\n\n\n\n
Now, I can compare MyInt<\/code> and MyDouble<\/code> for equality and inequality.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
I applied a neat trick in the program equalityOperator.cpp<\/code>. Can you spot it? <\/p>\n\n\n\n
<\/p>\n\n\n\n
In the following example, I implemented the equality operator of MyInt<\/code> by chaining the equality operators of value<\/code> and mySet<\/code>.<\/p>\n\n\n\n
struct<\/span> MyInt {\n    int<\/span> value;\n    std::<\/span>unordered_set<<\/span>int<\/span>><\/span> mySet;\n    explicit<\/span> MyInt(int<\/span> val):<\/span> value{val}, mySet{val} { }\n    bool<\/span> operator<\/span>==<\/span>(const<\/span> MyInt&<\/span> rhs) const<\/span> {\n        if<\/span> (auto<\/span> first =<\/span> value ==<\/span> rhs.value; first !=<\/span> 0<\/span>) return<\/span> first;\n        else<\/span> return<\/span> mySet ==<\/span> rhs.mySet; \n    }\n};\n<\/pre><\/div>\n\n\n\n
This is pretty ugly and error-prone if you have a class with more members<\/p>\n\n\n\n
On the contrary, I used std::tie <\/code>to implement the equality operator in the program equalityOperator.cpp<\/code>.<\/p>\n\n\n\n
struct<\/span> MyInt {\n    int<\/span> value;\n    std::<\/span>unordered_set<<\/span>int<\/span>><\/span> mySet;\n    explicit<\/span> MyInt<\/span>(int<\/span> val):<\/span> value{val}, mySet{val} { }\n    bool<\/span> operator<\/span>==<\/span>(const<\/span> MyInt&<\/span> rhs) const<\/span> {                 \n        return<\/span> std::<\/span>tie(value, mySet) ==<\/span> std::<\/span>tie(rhs.value, rhs.mySet);\n    }\n};\n<\/pre><\/div>\n\n\n\n
std::tie<\/a><\/code> creates a tuple of lvalue references to its arguments. Finally, the created tuples are lexicographically compared. <\/p>\n\n\n\n
What’s Next?<\/h2>\n\n\n\n
In my next post, I will continue my journey through C++20 and write about std::span. std::span <\/code>represents an object that refers to a contiguous sequence of objects.<\/p>\n","protected":false},"excerpt":{"rendered":"
You can define the three-way comparison operator or request it from the compiler with =default. But do you know that you can also define or request the equality operator in C++20? Before I dive into the autogenerated equality operator, I’d like to refresh your knowledge about the three-way comparison operator. The Three-Way Comparison Operator You […]<\/p>\n","protected":false},"author":21,"featured_media":8847,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[462],"class_list":["post-8844","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\/8844","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=8844"}],"version-history":[{"count":21,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/8844\/revisions"}],"predecessor-version":[{"id":8887,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/8844\/revisions\/8887"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/8847"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=8844"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=8844"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=8844"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}