C++ move assignment operator

C++'s move assignment operator is a special assignment operator used to move a resource from one object to another without making a deep copy. Move assignment operators are often used to support move semantics to improve code efficiency and performance.

The move assignment operator is defined as follows:

class MyClass {
public:
    // 移动赋值运算符
    MyClass& operator=(MyClass&& other) noexcept {
        if (this != &other) {
            // 释放当前对象的资源
            // 移动源对象的资源到当前对象
            // 置空源对象的资源
        }
        return *this;
    }
};

Compared with other assignment operators, the move assignment operator has one more in front of the parameter type &&, indicating an rvalue reference. By using an rvalue reference, we can get the source object to be assigned and move its resources into the target object.

In a move-assignment operator, one usually does the following:

Check whether it is a self-assignment condition, and if so, return the current object directly.
Release the resources of the current object to prevent resource leaks.
Copy the resource pointer or resource handle of the source object to the target object, avoiding deep copy.
Set the resource pointer or resource handle of the source object nullptrto ensure that the resource will not be released when the source object is destroyed.

Here is a simple sample code showing how to define and use the move assignment operator:

#include <iostream>

class MyString {
public:
    char* data;

    MyString(const char* str) {
        int length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);
    }

    ~MyString() {
        delete[] data;
    }

    // 移动赋值运算符
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            other.data = nullptr;
        }
        return *this;
    }
};

int main() {
    MyString str1("Hello");
    MyString str2("World");

    str2 = std::move(str1);  // 调用移动赋值运算符

    std::cout << str2.data << std::endl;  // 输出 "Hello"

    return 0;
}

In the above example, we defined a simple MyStringclass that contains a resource pointer dataand a move assignment operator. In the move assignment operator, we first check whether it is a self-assignment situation, if not, release the resource of the current object, assign the resource pointer of the source object to the target object, and then set the resource pointer of the source object datato nullptr.

In main()the function, we create two objects str1and str2then use std::move()the function to str1convert to an rvalue reference and assign it to str2the object. This triggers an invocation of the move assignment operator, moving the resource from str1to str2, which eventually outputs "Hello".

Using the move assignment operator can avoid unnecessary data copying, especially when the object has a lot of resources, move semantics can significantly improve the performance and efficiency of the code. Move assignment operators are often used together with move constructors to enable efficient management and transfer of resources.

My blog will soon be synchronized to the Tencent Cloud developer community, and everyone is invited to join: https://cloud.tencent.com/developer/support-plan?invite_code=1tor251nnv85f

C++ move assignment operator

Guess you like