Assignment operator (C++)

<h2 id="return-value-of-overloaded-assignment-operator">Return value of overloaded assignment operator</h2>
<p>The language permits an overloaded assignment operator to have an arbitrary return type (including <a href="/facts/Void_type/qbMrxVtl">void</a>). However, the operator is usually defined to return a reference to the assignee. This is consistent with the behavior of assignment operator for built-in types (<a href="/facts/Assignment_(computer_science)/kLevAoyJ">returning the assigned value</a>) and allows for using the operator invocation as an expression, for instance in control statements or in <a href="/facts/Assignment_(computer_science)/kLevAoyJ">chained assignment</a>. Also, the <a href="/facts/C%252B%252B_Standard_Library/A5vQNSAD">C++ Standard Library</a> requires this behavior for some user-supplied types.<a class="footnote-ref" id="fnref:2" href="#fn:2"><sup>2</sup></a>
</p>
<h2 id="overloading-copy-assignment-operator">Overloading copy assignment operator</h2>
<p>When <a href="/facts/Deep_copy/QbBS3suW">deep copies</a> of objects have to be made, <a href="/facts/Exception_safety/Hevphbsh">exception safety</a> should be taken into consideration. One way to achieve this when resource deallocation never fails is:
</p>
<ol><li>Acquire new resources</li>
<li>Release old resources</li>
<li>Assign the new resources' handles to the object</li></ol>
class My_Array{
    int* array;
    int count;
public:
    My_Array& operator=(const My_Array& other)
    {
        if (this != &other) { // protect against invalid self-assignment
            // 1: allocate new memory and copy the elements
            int* new_array = new int[other.count];
            std::copy(other.array, other.array + other.count, new_array);

// 2: deallocate old memory
            delete[] array;

// 3: assign the new memory to the object
            array = new_array;
            count = other.count;
        }
        // by convention, always return *this
        return *this;
    }
    // ...
};

<p>However, if a no-fail (<a href="/facts/Exception_guarantees/Hevphbsh">no-throw</a>) <a href="/facts/Swap_(computer_science)/lMfoMXCq">swap</a> function is available for all the member subobjects and the class provides a <a href="/facts/Copy_constructor/8JNHsH5H">copy constructor</a> and <a href="/facts/Destructor_(computer_science)/gr4051ve">destructor</a> (which it should do according to the <a href="/facts/Rule_of_three_(C%252B%252B_programming)/VVAvmfao">rule of three</a>), the most straightforward way to implement copy assignment is as follows:<a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a>
</p>
public:

void swap(My_Array& other) // the swap member function (should never fail!)
    {
        // swap all the members (and base subobject, if applicable) with other
        using std::swap; // because of ADL the compiler will use 
        // custom swap for members if it exists
        // falling back to std::swap
        swap(array, other.array);
        swap(count, other.count);
    }

My_Array& operator = (My_Array other) // note: argument passed by value!
    {
        // swap this with other
        swap(other);

// by convention, always return *this
        return *this;

// other is destroyed, releasing the memory
    }

<h2 id="assignment-between-different-classes">Assignment between different classes</h2>
<p>C++ supports assignment between different classes, both via implicit <a href="/facts/Copy_constructor/8JNHsH5H">copy constructor</a> and assignment operator, if the destination instance class is the ancestor of the source instance class:
</p>
class Ancestor {
public:
    int a;
};

class Descendant : public Ancestor {
public:
    int b;
};

int main()
{
    Descendant d;
    Ancestor a(d);
    Ancestor b(d);
    a = d;
}

<p>Copying from ancestor to descendant objects, which could leave descendant's fields uninitialized, is not permitted.
</p>
<h2 id="see-also">See also</h2>
<ul><li><a href="/facts/Operator_overloading/hRyHs4Qf">Operator overloading</a></li>
<li><a href="/facts/Move_assignment_operator/KDnyFYNC">Move assignment operator</a></li>
<li><a href="/facts/Rule_of_three_(C%252B%252B_programming)/VVAvmfao">Rule of three (C++ programming)</a></li>
<li><a href="/facts/Operators_in_C_and_C%252B%252B/6sAAkUBM">Operators in C and C++</a></li></ul>

<h2 id="external-links">External links</h2>
<ul><li><a href="http://icu-project.org/docs/papers/cpp_report/the_anatomy_of_the_assignment_operator.html">The Anatomy of the Assignment Operator</a>, by Richard Gillam</li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>Stroustrup, Bjarne (2000). The C++ Programming Language (3 ed.). Addison-Wesley. p. 244. ISBN 978-0-201-70073-2. <a href="978-0-201-70073-2" target="_blank">978-0-201-70073-2</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>Working Draft, Standard for Programming Language C++, Section 17.6.3.1, Table 23; http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf" target="_blank">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>Sutter, H.; Alexandrescu, A. (October 2004), C++ Coding Standards, Addison-Wesley, ISBN 0-321-11358-6 <a href="0-321-11358-6" target="_blank">0-321-11358-6</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
</ol>

Assignment operator (C++) open-in-new

Assignment operator (C++)