Assignment operator (C++)

In the C++ programming language, the assignment operator, =, is the operator used for assignment. Like most other operators in C++, it can be overloaded.

The copy assignment operator, often just called the "assignment operator", is a special case of assignment operator where the source (right-hand side) and destination (left-hand side) are of the same class type. It is one of the special member functions, which means that a default version of it is generated automatically by the compiler if the programmer does not declare one. The default version performs a memberwise copy, where each member is copied by its own copy assignment operator (which may also be programmer-declared or compiler-generated).

The copy assignment operator differs from the copy constructor in that it must clean up the data members of the assignment's target (and correctly handle self-assignment) whereas the copy constructor assigns values to uninitialized data members.

For example, consider some type X:

X first; // initialization by default constructor
X second(first); // initialization by copy constructor
X third = first; // Also initialization by copy constructor
second = third; // assignment by copy assignment operator

The usual signatures of the assignment operators are, for a class X:

// Copy assignment operator
X& operator=(const X& other);

// Move assignment operator
X& operator=(X&& other) noexcept;

Return value of overloaded assignment operator

The language permits an overloaded assignment operator to have an arbitrary return type (including void). 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 (returning the assigned value) and allows for using the operator invocation as an expression, for instance in control statements or in chained assignment. Also, the C++ Standard Library requires this behavior for some user-supplied types.

Overloading copy assignment operator

When deep copies of objects have to be made, exception safety should be taken into consideration. One way to achieve this when resource deallocation never fails is:

  1. Acquire new resources
  2. Release old resources
  3. Assign the new resources' handles to the object
import std;

class IntArray {
private:
    int* contents;
    int count;
public:
    IntArray& operator=(const IntArray& other) {
        if (this != &other) { // protect against invalid self-assignment
            // 1: allocate new memory and copy the elements
            int* newContents = new int[other.length];
            std::ranges::copy(other.contents, newContents);

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

            // 3: assign the new memory to the object
            contents = newContents;
            length = other.length;
        }
        // by convention, always return *this
        return *this;
    }
    // ...
};

However, if a no-fail (noexcept) swap function is available for all the member subobjects and the class provides a copy constructor and destructor (which it should do according to the rule of three), the most straightforward way to implement copy assignment is as follows:

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

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

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

    // other is destroyed, releasing the memory
}

Assignment between different classes

C++ supports assignment between different classes, both via implicit copy constructor and assignment operator, if the destination instance class is the ancestor of the source instance class:

// Ancestor class
struct Ancestor {
    int a;
};

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

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

Copying from Ancestor to Descendant objects, which could leave Descendant's fields uninitialized, is not permitted.

See also