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;
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.
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:
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
}
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.