{"id":105693,"date":"2021-09-16T07:00:00","date_gmt":"2021-09-16T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=105693"},"modified":"2021-10-08T10:33:05","modified_gmt":"2021-10-08T17:33:05","slug":"20210916-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20210916-00\/?p=105693","title":{"rendered":"The C++ implicit assignment operator is a non-ref-qualified member, even if the base class’s assignment has a ref-qualifier"},"content":{"rendered":"

Consider the following C++ class:<\/p>\n

struct Base\r\n{\r\n    Base& operator=(Base const&) & = default;\r\n\r\n    void BaseMethod();\r\n};\r\n<\/pre>\n
This defines a class for which you can assign to an lvalue reference, but not to an rvalue reference.<\/p>\n
extern Base GetBase();\r\n\r\nBase b;\r\nb = GetBase(); \/\/ allowed\r\nGetBase() = b; \/\/ not allowed\r\n<\/pre>\n
Assigning to an rvalue is not generally useful, since the object has no name, and consequently it is difficult to do anything with the assigned-to object afterward.\u00b9<\/p>\n
Great, we got rid of assignment to a temporary, which we’ve seen  has been a source of confusion<\/a>.<\/p>\n
Now consider this:<\/p>\n
struct Derived : Base\r\n{\r\n};\r\n\r\nDerived d;\r\nDerived() = d; \/\/ is this allowed?\r\n<\/pre>\n
We created a derived class and inherited the assignment operator from it. Do you expect the inherited assignment operator to block rvalues?<\/p>\n
You probably guessed that the answer is no<\/i>, seeing as I gave it away in the title.<\/p>\n
The reason is that I lied when I said that the assignment operator was inherited. It was not inherited. It was implicitly declared<\/i>.<\/p>\n
The rules for implicit declaration of the copy assignment operator are spelled out in  [class.copy.assign]<\/b><\/a>, paragraphs 2 and 4. The short version is that a class is eligible for an implicitly-declared copy assignment operator if its base classes and non-static members all have a copy assignment operator. (Analogous rules apply for the implicitly-declared move assignment operator.)<\/p>\n
The catch is that the implicitly-declared copy assignment and move assignment operators are declared as an unqualified<\/i> assignment operator, regardless of the reference-qualifications of the base classes and members. In our example, we get<\/p>\n
struct Derived : Base\r\n{\r\n    \/\/ compiler autogenerates these\r\n    Derived& operator=(Derived const&) = default;\r\n    \/\/                                ^ no &\r\n};\r\n<\/pre>\n
The lack of a ref-qualification means that this assignment operator applies equally to lvalues and rvalues.<\/p>\n
Our attempt to block rvalue assignment fails to propagate to derived classes!<\/p>\n
In order to repair this, each derived class must redeclare its assignment operator as lvalue-only.<\/p>\n
struct Derived : Base\r\n{\r\n    Derived& operator=(Derived const&) & = default;<\/span>\r\n};\r\n<\/pre>\n
Oh, we’ve only started our journey down the rabbit-hole.<\/p>\n
At least for now, explicitly declaring a copy assignment operator does not cause the implicitly-declared copy\/move constructors to disappear, but the behavior is noted as deprecated in the C++ language specification, with the note that a future version of the language may indeed delete them.<\/p>\n
Derived d;\r\nDerived d2{ d }; \/\/ on borrowed time\r\n<\/pre>\n
To make sure you don’t run into trouble in the future, you’ll want to declare them explicitly.<\/p>\n
struct Derived : Base\r\n{\r\n    Derived(Derived const&) = default;<\/span>\r\n    Derived(Derived&&) = default;<\/span>\r\n    Derived& operator=(Derived const&) & = default;\r\n};\r\n<\/pre>\n
Great, we’ve restored the copy and move constructors.<\/p>\n
But explicitly declaring any constructors causes us to lose the implicitly-declared default constructor.<\/p>\n
Derived d; \/\/ doesn't work any more\r\n<\/pre>\n
We’ll have to bring that back too.<\/p>\n
struct Derived : Base\r\n{\r\n    Derived() = default;<\/span>\r\n    Derived(Derived const&) = default;\r\n    Derived(Derived&&) = default;\r\n    Derived& operator=(Derived const&) & = default;\r\n};\r\n<\/pre>\n
The same exercise applies if we also want to block the move assignment operator to rvalues, but it’s more urgent because an explicit declaration of a move assignment operator does delete both the copy and move constructors even in C++20.<\/p>\n
struct Base\r\n{\r\n    Base& operator=(Base const&) & = default;\r\n    Base& operator=(Base&&) & = default;<\/span>\r\n\r\n    void BaseMethod();\r\n};\r\n\r\nstruct Derived : Base\r\n{\r\n    Derived() = default;\r\n    Derived(Derived const&) = default;\r\n    Derived(Derived&&) = default;\r\n    Derived& operator=(Derived const&) & = default;\r\n    Derived& operator=(Derived&&) & = default;<\/span>\r\n};\r\n<\/pre>\n
Phew, that was annoying.<\/p>\n
\u00b9 I mean, I guess you could do this:<\/p>\n
Base b;\r\n\r\nSomething(GetBase() = b);\r\n(GetBase() = b).BaseMethod();\r\n<\/pre>\n
but it seems pointless to go to the effort of asking Get\u00adBase<\/code> to create you a Base<\/code> object, only to overwrite it with your own. You may as well just create your own temporary.<\/p>\n
Something(Base(b));\r\nBase(b).BaseMethod();\r\n<\/pre>\n
Or, if you didn’t even mean to create a temporary, just use the original value:<\/p>\n
Something(b);\r\nb.BaseMethod();\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
Does that count as dis-qualification?<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-105693","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Does that count as dis-qualification?<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/105693","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=105693"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/105693\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=105693"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=105693"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=105693"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}