Skip to main content

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.

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. 
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.
#include <cstddef>
#include <utility>

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().
#include <utility>
#include <vector>
#include <cstddef>

// Assuming the Buffer class defined above

void manageBuffers() {
    std::vector<Buffer> 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.
Master C++ with Deep Grasping Methodology!Learn More