Init

cppdraft/over/assign.md

@@ -0,0 +1,59 @@
+[over.assign]
+
+# 12 Overloading [[over]](./#over)
+
+## 12.4 Overloaded operators [[over.oper]](over.oper#over.assign)
+
+### 12.4.3 Binary operators [[over.binary]](over.binary#over.assign)
+
+#### 12.4.3.2 Simple assignment [over.assign]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/overloading.tex#L3566)
+
+A [*simple assignment operator function*](#def:operator_function,simple_assignment "12.4.3.2 Simple assignment [over.assign]") is a binary operator function named operator=[.](#1.sentence-1)
+
+A simple assignment operator function shall be a non-static member function[.](#1.sentence-2)
+
+[*Note [1](#note-1)*:
+
+Because only standard conversion sequences are considered when converting
+to the left operand of an assignment operation ([[over.best.ics]](over.best.ics "12.2.4.2 Implicit conversion sequences")),
+an expression x = y with a subexpression x of class type
+is always interpreted as x.operator=(y)[.](#1.sentence-3)
+
+— *end note*]
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/overloading.tex#L3577)
+
+[*Note [2](#note-2)*:
+
+Since a copy assignment operator is implicitly declared for a class
+if not declared by the user ([[class.copy.assign]](class.copy.assign "11.4.6 Copy/move assignment operator")),
+a base class assignment operator function is always hidden by
+the copy assignment operator function of the derived class[.](#2.sentence-1)
+
+— *end note*]
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/overloading.tex#L3585)
+
+[*Note [3](#note-3)*:
+
+Any assignment operator function, even the copy and move assignment operators,
+can be virtual[.](#3.sentence-1)
+
+For a derived class D with a base class B for which a virtual copy/move assignment has been declared,
+the copy/move assignment operator in D does not overrideB's virtual copy/move assignment operator[.](#3.sentence-2)
+
+[*Example [1](#example-1)*: struct B {virtual int operator= (int); virtual B& operator= (const B&);};struct D : B {virtual int operator= (int); virtual D& operator= (const B&);};
+
+D dobj1;
+D dobj2;
+B* bptr = &dobj1;void f() { bptr->operator=(99); // calls D​::​operator=(int)*bptr = 99; // ditto bptr->operator=(dobj2); // calls D​::​operator=(const B&)*bptr = dobj2; // ditto dobj1 = dobj2; // calls implicitly-declared D​::​operator=(const D&)} — *end example*]
+
+— *end note*]