Move semantics is a feature introduced by C 11 to optimize resource management and reduce unnecessary copy operations. Its core idea is to directly transfer the object's resources rather than copying when it is about to be destroyed, and it is implemented through moving constructors and moving assignment operators. For example, std::move converts lvalues ??to rvalue references to trigger a move operation instead of actually performing a move. Unlike copy, moving usually puts the original object in an empty or invalid but legal state, such as a null pointer or an empty vector. Common applicable scenarios include processing large objects, returning local objects to containers, adding elements and resource management classes, but excessive use should be avoided in small objects or high-frequency call paths. Correctly writing moving constructors and assignment operators and understanding resource transfer timing are the key to mastering this feature.

Move Semantics of C is an important feature introduced by C 11. Its core lies in optimizing resource management and reducing unnecessary copy operations. Simply put, when an object is about to be destroyed or no longer needed, we can "mov" its resources instead of copying it, thereby improving performance.

What is moving semantics?

In traditional C, when we assign or pass arguments, the copy constructor or copy assignment operator is often triggered, which means that the resource will be copied in full. For example, when a std::vector is copied, the internal heap memory will be re-allocated and the data will be copied.

The core idea of ??mobile semantics is: if an object is soon destroyed (such as a temporary variable), then we can "steal" its resources directly instead of trying to copy a copy. This "stealing" process is achieved through moving constructors and moving assignment operators .

For example:

 std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = std::move(v1); // The content of v1 is "moved" to v2, and v1 is now in a valid but undefined state

std::move here is not really performing a move operation, it just converts v1 into an rvalue reference type, telling the compiler: "I can be moved".

Mobile vs Copy: What's the difference?

• Copy : Create a new object and copy everything from the original object. Applicable to immutable objects or the original objects still need to be retained.
• Move : "transferring" resources from one object to another will usually make the original object empty or invalid, but it is still legal (such as null pointers or null vectors).

For example, suppose you have a dynamically allocated array class:

 class MyArray {
    int* data;
    size_t size;
public:
    // Copy constructor MyArray(const MyArray& other) {
        data = new int[other.size];
        std::copy(other.data, other.data other.size, data);
        size = other.size;
    }

    // Move constructor MyArray(MyArray&& other) noexcept {
        data = other.data;
        size = other.size;
        other.data = nullptr; // The original object no longer has the resource other.size = 0;
    }
};

It can be seen that copying requires applying for new memory and copying data, while mobile directly "take over" existing resources, which is much more efficient.

Rvalue reference with std::move

To understand the movement semantics, you must understand the rvalue reference . The rvalue reference is represented by T&& and can be bound to a temporary object (i.e., an rvalue).

• Lvalue: an object with a name that can take addresses, such as variables.
• Rvalue: A temporary object, cannot take address, such as literals and expression results.

The purpose of std::move is to cast an lvalue to an rvalue reference, allowing the call to a move constructor or a move assignment operator.

What should be noted is:

• After using std::move , the state of the original object is usually valid but uncertain.
• It is not recommended to use std::move for constant references, as that can lead to unexpected behavior.

When should mobile semantics be used?

• Moving semantics can significantly improve performance when dealing with large objects (such as containers, strings, custom resource classes).
• Modern compilers usually optimize automatically (NRVO) when returning local objects, but explicit movement can also help with optimization in some cases.
• When writing generic library code, supporting mobile semantics allows your class to work more efficiently with other standard library components.

Some common scenarios include:

• Function returns local object
• Add elements to the container (such as push_back(std::move(x)) )
• Resource management category (file handles, network connections, etc.)

But also note:

• If the object itself is small or has no dynamic resources, the benefits of movement may not be large.
• Don't overuse std::move , especially in code paths that are looped or high-frequency calls.

Basically that's it. The key to mastering mobile semantics is to understand when and where resource transfer is suitable, and how to properly write and use mobile constructors and mobile assignment operators.

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