Understanding move assignment operator in C

The move assignment operator in C is a special member function that efficiently transfers resources from a temporary object to an existing one. It is defined as MyClass& operator=(MyClass&& other) noexcept;, taking a non-const rvalue reference to allow modification of the source object. You should define it when managing resources manually, when default behavior is insufficient, or when needing exception safety. Unlike the copy assignment operator, which copies data, the move assignment operator "steals" resources, leaving the source in a valid but unspecified state. Best practices include checking for self-assignment, releasing existing resources, leaving the source destructible, marking the function noexcept, and following the Rule of Five. Forgetting to nullify pointers or mishandling resource cleanup can lead to errors like double deletion. When members support move semantics, delegating to their move assignment simplifies implementation.

In C , the move assignment operator is a special member function that handles resource transfer when an object is assigned from an rvalue (like a temporary or explicitly moved object). It's key to writing efficient code, especially when dealing with dynamic memory or other costly resources.

What is the move assignment operator?

The move assignment operator replaces the contents of an existing object by "stealing" resources from a temporary object. This avoids expensive deep copies and allows for optimizations like moving memory buffers instead of copying them.

Its typical signature looks like this:

MyClass& operator=(MyClass&& other) noexcept;

Unlike the copy assignment operator, which takes a const lvalue reference, the move assignment operator takes a non-const rvalue reference — indicating it can modify and “pillage” the source object.

This is important because in many cases, such as with std::vector, reallocations happen by moving elements rather than copying them, which significantly improves performance.

When should you define your own move assignment operator?

You should define your own move assignment operator if:

• Your class manages resources manually (e.g., raw pointers, file handles).
• The default behavior doesn’t do what you need.
• You want to ensure exception safety or specific cleanup logic during moves.

By default, C will generate a move assignment operator for you if no user-defined copy operations, move operations, or destructors are present.

For example:

class MyString {
    char* data;
    size_t length;

public:
    // Define move assignment to handle 'data' properly
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] data;  // Free current resource
            data = other.data;
            length = other.length;
            other.data = nullptr;  // Leave source in valid state
            other.length = 0;
        }
        return *this;
    }
};

If you don't write one and your class contains members that have move semantics, the compiler-generated version will try to move each member — which might be exactly what you want.

How does it differ from the copy assignment operator?

The main difference lies in what they operate on and how they treat the source object:

• Copy assignment (operator=(const MyClass&)) makes a deep copy of the source.
• Move assignment steals resources from the source, leaving it in a valid but unspecified state.

For example, when using std::unique_ptr, you can’t copy it (because it’s non-copyable), but you can move it — transferring ownership of the managed pointer.

Another practical example: containers like std::vector use move assignment to efficiently resize when elements are moved instead of copied.

Also, move assignment usually sets the source object's internal pointers to nullptr or resets values, so destruction is safe and fast.

Best practices when implementing move assignment

Here are some key points to keep in mind:

• Always check for self-assignment (if (this != &other)).
• Release any existing resources before taking over new ones.
• Leave the source object in a destructible state — ideally, setting its internal pointers to nullptr.
• Mark the function noexcept unless there's a reason not to.
• If you define a move constructor or move assignment operator, consider defining all five special member functions (including destructor, copy operations) to follow the Rule of Five.

A common mistake is forgetting to nullify pointers after moving, which can lead to double deletion or dangling pointers.

Another point worth mentioning: if your class has members that themselves support move semantics, you can delegate the move operation to them:

MyClass& operator=(MyClass&& other) noexcept {
    if (this != &other) {
        resource = std::move(other.resource);  // Delegates to member's move assignment
    }
    return *this;
}

This keeps your implementation clean and lets the standard library handle the details.

That's basically how move assignment works in practice. It's not hard once you understand what it's meant to achieve, but easy to mess up if you forget to manage resources correctly.

The above is the detailed content of Understanding move assignment operator in C. For more information, please follow other related articles on the PHP Chinese website!