> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Move Constructor A move constructor is a special member function in C++ that initializes a new object by acquiring the resources of an rvalue (a temporary or explicitly moved object) instead of performing a deep copy. It transfers ownership of heap-allocated memory, file handles, or other managed resources from the source object to the newly constructed object, leaving the source in a valid but unspecified state. ## Syntax A move constructor is declared using an rvalue reference (`&&`) to the class type. It is highly recommended to mark it `noexcept`. ```cpp theme={"dark"} class ClassName { public: // Move constructor signature ClassName(ClassName&& other) noexcept; }; ``` ## Mechanics of a Move Constructor The implementation of a move constructor relies on two distinct mechanical steps to safely transfer resource ownership: 1. **Resource Pilfering (Shallow Copy):** The constructor copies the memory addresses or resource handles (e.g., raw pointers, file descriptors) directly from the source object to the new object. 2. **Source Nullification:** The constructor explicitly resets the source object's pointers to `nullptr` and its scalar values to zero (or default states). This prevents the source object's destructor from deallocating the memory that is now owned by the new object, thereby avoiding double-free vulnerabilities. ```cpp theme={"dark"} #include #include class Buffer { private: int* data; std::size_t size; public: // Standard constructor // Members are initialized in the exact order of declaration Buffer(std::size_t s) : data(new int[s]), size(s) {} // 1. Move Constructor Buffer(Buffer&& other) noexcept : data(other.data), // Acquire pointer to existing memory size(other.size) // Acquire scalar state { // Nullify the source object's state other.data = nullptr; other.size = 0; } // 2. Destructor ~Buffer() { // If this object was moved from, data is nullptr. // delete[] nullptr is a safe, no-op operation. delete[] data; } // 3. Copy Constructor (Deleted to enforce move-only semantics) Buffer(const Buffer& other) = delete; // 4. Copy Assignment Operator (Deleted) Buffer& operator=(const Buffer& other) = delete; // 5. Move Assignment Operator Buffer& operator=(Buffer&& other) noexcept { if (this != &other) { delete[] data; // Free existing resource data = other.data; // Pilfer resources size = other.size; other.data = nullptr;// Nullify source other.size = 0; } return *this; } }; ``` ## Invocation Triggers The compiler invokes the move constructor when an object is initialized from an rvalue. Since C++17 introduced guaranteed copy elision, directly initializing an object from a prvalue (e.g., `Buffer b = Buffer(100);`) constructs the object directly in place. The prvalue acts merely as an initialization recipe, *preventing* the materialization of a temporary object and bypassing the move constructor entirely. Instead, the move constructor is actively invoked in contexts such as: * **Prvalues bound to rvalue references:** When passing a temporary object to a function or container method that accepts an rvalue reference (e.g., `std::vector::push_back(T&&)`), a temporary materialization conversion occurs. The prvalue is materialized into an xvalue so it can bind to the reference, allowing the internal implementation to invoke the move constructor. * **Xvalues (eXpiring values):** Initialization from an lvalue that has been explicitly cast to an rvalue reference using `std::move()`. ```cpp theme={"dark"} #include #include #include // Assuming the Buffer class defined above void manageBuffers() { std::vector buffers; // 1. Invoked via prvalue binding to an rvalue reference // The temporary Buffer(100) undergoes temporary materialization to bind // to push_back(T&&), which internally invokes the move constructor. buffers.push_back(Buffer(100)); Buffer b1(50); // 2. Invoked via xvalue (explicit cast to rvalue reference) // std::move casts the lvalue 'b1' to an xvalue, triggering the move constructor. Buffer b2 = std::move(b1); } ``` ## The `noexcept` Specifier Move constructors should almost always be declared `noexcept`. Standard library containers (such as `std::vector`) provide strong exception safety guarantees during reallocation. They utilize `std::move_if_noexcept` to determine whether to move or copy elements. If a move constructor is not marked `noexcept` and the type is *copy-constructible*, the container will silently fall back to using the copy constructor to ensure that an exception thrown mid-transfer does not leave the container in a corrupted state. However, if the type is *move-only* (its copy constructor is deleted), `std::move_if_noexcept` will still return an rvalue reference. The container is then forced to use the throwing move constructor, sacrificing the strong exception guarantee. ## Compiler Generation Rules The C++ compiler will implicitly generate a default move constructor (which performs a member-wise move) only if the class does not explicitly declare any of the following: * Copy constructor * Copy assignment operator * Move assignment operator * Destructor If a class manages resources requiring a custom move constructor, it falls under the **Rule of Five**, dictating that the developer must explicitly define (or explicitly `= delete` / `= default`) all five of the aforementioned special member functions to ensure deterministic resource management, as demonstrated in the `Buffer` example above.

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More