What is a Move Constructor?
Learn what a move constructor is, how T&& works, and why it beats the copy constructor for performance, with examples and Q&A.
Expected Interview Answer
A move constructor is a special constructor (in C++, T(T&& other)) that builds a new object by transferring ownership of an existing rvalue object’s internal resources rather than copying them, leaving the source object in a valid but empty state.
It takes its argument as an rvalue reference (T&&), which binds only to temporaries and objects explicitly cast with std::move, signalling that the source is about to be discarded and its internals can safely be pilfered instead of duplicated. Inside the move constructor, the new object simply takes the source’s pointers or handles directly (a constant-time pointer copy) and then sets the source’s pointers to null so that when the source’s destructor eventually runs, it doesn’t free memory the new object now owns. This is what makes returning large objects from functions, inserting elements into a resizing std::vector, and using move-only types like unique_ptr efficient — none of them need to pay for a full deep copy of data that’s about to disappear anyway. If a class doesn’t declare a move constructor (and none is implicitly generated, which happens if you declare a custom destructor or copy constructor), move-eligible calls silently fall back to the more expensive copy constructor instead.
- Avoids a full deep copy when the source object is a temporary about to be destroyed
- Makes returning large objects by value and container growth efficient
- Enables move-only resource-owning types like unique_ptr and file handles
- Runs in constant time regardless of how much data the source owns
AI Mentor Explanation
When a franchise disbands right after the season, its still-under-contract star player doesn’t need to be re-scouted and re-signed from scratch by a new club — the new club can simply take over the existing contract directly, since the old club is folding anyway and has no further use for it. That direct handover, done because the source club is going away, is what a move constructor does: it builds the new object by taking over the source’s resources directly, only because the source is about to be discarded, rather than duplicating everything as a copy constructor would.
Step-by-Step Explanation
Step 1
Accept an rvalue reference parameter
Declare the constructor as T(T&& other) so it binds to temporaries and std::move-cast objects.
Step 2
Steal the source's pointers/handles
Copy the source's internal pointer(s) into the new object directly, a constant-time operation.
Step 3
Null out the source
Set the source's internal pointers to null (or an empty state) so it no longer references the transferred resource.
Step 4
Leave the source destructible
The source must remain in a valid state so its destructor can run safely without double-freeing anything.
What Interviewer Expects
- Correct signature: takes an rvalue reference (T&&), not a const reference
- Explanation of why it is cheaper than the copy constructor for resource-owning types
- Mention that the source is left in a valid, destructible, but unspecified state
- Awareness of when the compiler auto-generates one versus when it is suppressed
Common Mistakes
- Forgetting to null out the source's pointers, causing a double-free when both objects' destructors run
- Confusing the move constructor's T&& parameter with a plain reference or const reference
- Assuming every class gets a compiler-generated move constructor automatically, when declaring a custom destructor or copy constructor suppresses it
- Not marking the move constructor noexcept, which can prevent standard containers from using it during reallocation
Best Answer (HR Friendly)
“A move constructor builds a new object by taking over the internal resources of a temporary or explicitly-moved-from object, instead of copying its data. Because the source object is about to be discarded anyway, it’s safe to just steal its pointers and leave it empty, which is much faster than a full deep copy — this is what makes things like returning large objects from functions or growing a vector efficient in C++.”
Code Example
// Java has no move constructors or rvalue references -- every object is
// accessed through a reference, and the garbage collector reclaims memory,
// so there is no manual resource-stealing to do. This class simulates the
// *intent* of a C++ move constructor: build a new object by taking over
// another object’s resource and leaving the source empty.
public class OwnedBuffer {
private byte[] data;
// Regular ("copy-like") constructor: deep copy, independent data
public OwnedBuffer(OwnedBuffer other, boolean deepCopy) {
this.data = deepCopy ? other.data.clone() : other.data;
}
// "Move constructor" style factory: steal the source’s array,
// then null out the source so it can’t be used as if still valid.
public static OwnedBuffer moveFrom(OwnedBuffer source) {
OwnedBuffer moved = new OwnedBuffer(source, false);
source.data = null; // source is left empty, like a moved-from C++ object
return moved;
}
}Follow-up Questions
- How does a move constructor differ from a copy constructor in both signature and cost?
- What conditions suppress the compiler-generated implicit move constructor?
- Why should a move constructor typically be marked noexcept?
- What state must the source object be left in after being moved from?
MCQ Practice
1. A move constructor's parameter type in C++ is?
A move constructor takes an rvalue reference, T&&, which binds to temporaries and std::move-cast objects.
2. After a move constructor runs, the source object should be?
The source must remain valid enough that its destructor can safely run, even though its contents are unspecified.
3. Declaring which of these typically suppresses the compiler-generated implicit move constructor?
Declaring a custom destructor (or copy constructor/assignment) suppresses the implicitly generated move constructor in C++.
Flash Cards
Move constructor in one line? — Builds a new object by transferring an rvalue source's resources instead of copying them.
Parameter type? — An rvalue reference, T&&.
Cost compared to copy constructor? — Constant-time pointer transfer versus a deep copy that scales with data size.
What must happen to the source afterward? — Its internal pointers are nulled out so it stays valid and destructible without double-freeing.