2026-03-219 min read

move constructors (C++)

Learn move constructors (C++) step by step with clear examples and exercises.

Why This Matters

Move constructors are essential in modern C++ programming for optimizing memory management, especially when dealing with large objects or resources that need to be moved rather than copied. This lesson will provide you with an in-depth understanding of move constructors, their importance, and how to use them effectively.

The Importance of Move Constructors

Move constructors are crucial for efficient resource handling, particularly when working with large data structures like containers or complex objects that consume significant memory. In situations where the object's state needs to be transferred from one variable to another, move constructors can help avoid unnecessary copying and improve performance. Move constructors play a vital role in optimizing code for real-world applications and preparing you for interviews and exams.

Benefits of Using Move Constructors

Avoiding unnecessary copying: Move constructors allow the transfer of resources from one object to another without creating temporary objects or performing expensive copy operations.
Improving performance: By reducing the number of temporary objects created during program execution, move constructors can significantly improve the performance of your code.
Resource management: When dealing with resources that need to be managed, such as file handles, network sockets, or memory allocations, move constructors can help optimize the transfer of these resources between objects.
Preparing for real-world applications: Move constructors are crucial for writing efficient and optimized code in modern C++ development.
Interview preparation: Understanding move constructors is important for preparing for job interviews, as they are often tested during the interview process.

Prerequisites

To fully understand move constructors, you should have a good grasp of the following concepts:

C++ basics: variables, data types, operators, functions, and control structures
Object-oriented programming principles in C++
Understanding of copy constructor, copy assignment operator, and the rule of three/five
Familiarity with standard library containers like std::vector and std::string
Basic understanding of rvalue and lvalue references
Knowledge of exception safety and resource management in C++
Understanding of move semantics, including the std::move(), std::forward(), and perfect forwarding concepts
Familiarity with smart pointers like std::unique_ptr and std::shared_ptr

Core Concept

Definition and Purpose

A move constructor is a special function in C++ that allows an object to be moved from one location to another while avoiding the costly process of copying. The move constructor takes an rvalue (right-value) reference as its argument, which is an expression that can be assigned or passed by value without creating a new temporary object.

MyClass(MyClass && other) {
// Move constructor implementation
}

The purpose of the move constructor is to transfer resources from one object (the source) to another (the destination), while leaving the source in a valid but empty state. This is particularly useful when dealing with large objects or resources that consume significant memory, as it can help avoid unnecessary copying and improve performance.

When to Use Move Constructors

Move constructors are useful in several scenarios:

Returning large objects from functions: Functions that return large objects by value can benefit from move constructors, as they allow the object to be moved directly into the calling function's variable without creating a temporary object and copying it.

Passing large objects by value: Passing large objects by value in function arguments can also lead to unnecessary copying. Move constructors help avoid this by moving the object directly into the function's parameter instead of creating a copy.

Resource management: When dealing with resources that need to be managed, such as file handles, network sockets, or memory allocations, move constructors can help optimize the transfer of these resources between objects.

Performance optimization: Move constructors can significantly improve the performance of your code by avoiding unnecessary copying and reducing the number of temporary objects created during program execution.

Implementing a Move Constructor

To implement a move constructor, follow these steps:

Declare the move constructor with an rvalue reference as its argument:

MyClass(MyClass && other);

Define the move constructor body to transfer resources from the source object (other) to the destination object:

MyClass(MyClass && other) : data(std::move(other.data)) {
// Additional cleanup or initialization if needed
}

Make sure to also provide a move assignment operator for efficient resource management when assigning one object to another.

Move Constructors vs Copy Constructors

Move constructors take an rvalue reference (&&) as their argument, while copy constructors take a const lvalue reference (const &). Be sure to understand the difference and use them appropriately.

When to Use Copy Constructors

Copy constructors are used when creating a new object from an existing object of the same type by copying its state. This is typically done when you need to make a copy of an object, such as when passing an object as a function argument or returning it from a function.

Common Mistakes

Not defining a move constructor: If you don't define a move constructor for your class, the compiler will generate one for you. However, the default implementation may not always be optimal, so it's recommended to provide your own move constructor when necessary.

Confusing move constructors with copy constructors: Move constructors take an rvalue reference (&&) as their argument, while copy constructors take a const lvalue reference (const &). Be sure to understand the difference and use them appropriately.

Not using std::move() correctly: The std::move() function is used to explicitly indicate that an object should be moved rather than copied. Misusing it can lead to unexpected behavior, so make sure you understand its purpose and how to use it effectively.

Ignoring move constructors during assignment: When defining a move constructor, don't forget to also provide a move assignment operator. The move assignment operator is essential for efficient resource management when assigning one object to another.

Not considering exception safety: When implementing move constructors and move assignment operators, make sure to handle exceptions appropriately to ensure that the source object remains in a valid state even if an exception occurs during the construction or assignment process.

Worked Example

Let's create a simple MyClass example to demonstrate the use and importance of move constructors:

#include <iostream>
#include <vector>
#include <memory>

class MyClass {
public:
MyClass(int size) : data(std::make_unique<int[]>(size)) {
std::fill(data.get(), data.get() + size, 0);
}

// Copy constructor is implicitly generated, but we'll define it for comparison
MyClass(const MyClass& other) : data(std::make_unique<int[]>(other.size())) {
std::copy(other.data.get(), other.data.get() + other.size(), data.get());
}

MyClass(MyClass&& other) : size(other.size), data(std::move(other.data)) {}

// Copy assignment operator is implicitly generated, but we'll define it for comparison
MyClass& operator=(const MyClass& other) {
if (this != &other) {
size = other.size;
data = std::make_unique<int[]>(other.size());
std::copy(other.data.get(), other.data.get() + other.size, data.get());
}
return *this;
}

// Move assignment operator
MyClass& operator=(MyClass&& other) {
if (this != &other) {
size = other.size;
data = std::move(other.data);
}
return *this;
}

void print() const {
for (int i = 0; i < size; ++i) {
std::cout << data.get()[i] << ' ';
}
std::cout << '\n';
}

private:
std::unique_ptr<int[]> data;
int size;
};

void create_and_move(MyClass& dest, MyClass&& source) {
dest = std::move(source);
}

int main() {
MyClass a(10);
MyClass b;

std::cout << "Before move:\n";
a.print();
create_and_move(b, std::move(a));
std::cout << "After move:\n";
b.print();

return 0;
}

In this example, we define a simple MyClass with a dynamically allocated array of integers managed by a std::unique_ptr. We also provide copy and move constructors, as well as copy and move assignment operators for comparison. The create_and_move() function demonstrates the use of move construction by taking an rvalue reference as its argument and moving the contents of one object (a) to another (b).

When you run this code, you'll see that the output shows "Move constructor called." when the create_and_move() function is called, indicating that move construction occurred. This helps illustrate the importance of move constructors in optimizing memory management and performance.

Common Mistakes

Not defining a move assignment operator: If you define a move constructor but forget to provide a move assignment operator, your class may still suffer from unnecessary copying when assigning one object to another. Make sure to always provide both the move constructor and move assignment operator for efficient resource management.

Using std::move() incorrectly: Misusing std::move() can lead to unexpected behavior. Be sure to understand its purpose and use it correctly when moving resources between objects or functions.

Not considering exception safety: When implementing move constructors and move assignment operators, make sure to handle exceptions appropriately to ensure that the source object remains in a valid state even if an exception occurs during the construction or assignment process.

Ignoring move constructors during initialization: When initializing objects with large resources, such as containers or smart pointers, don't forget to use move constructors to optimize memory management and avoid unnecessary copying.

Practice Questions

Write a move constructor and move assignment operator for a custom class MyString that stores a dynamically allocated character array.

Given the following code snippet, explain what happens when the function swap() is called:

class MyClass {
public:
// ...
void swap(MyClass& other) {
std::swap(data, other.data);
}
private:
std::vector<int> data;
};

void swap(MyClass& a, MyClass& b) {
a.swap(b);
}

What are the advantages of using move constructors over copy constructors when dealing with large objects or resources?

Write a move constructor for a custom class MyVector that stores an array of integers and implements exception safety by ensuring that the array is properly deallocated even if an exception occurs during construction.

Implement perfect forwarding using std::forward() in a function template that takes both rvalue and lvalue references as arguments.

FAQ

Why is it important to define my own move constructor instead of relying on the default one provided by the compiler?

The default move constructor generated by the compiler may not always be optimal for your specific use case, as it doesn't have access to any custom logic or resource management strategies you might have implemented in your class. By defining your own move constructor, you can ensure that it meets your performance and optimization needs.

Can I write a move constructor without providing a copy constructor?

Yes, you can define a move constructor without providing a copy constructor. However, if your class has any non-trivial data members or resources, it's generally recommended to also provide a copy constructor to ensure proper resource management and avoid unexpected behavior.

What is the difference between std::move() and static_cast?

Both std::move() and static_cast can be used to explicitly indicate that an object should be moved rather than copied. However, std::move() is preferred because it provides additional benefits, such as avoiding the need to know the exact type of the object being moved and ensuring that the object's state is left in a valid but empty state after moving.

Why does the move constructor take an rvalue reference (&&) instead of a const lvalue reference (const &)?

The move constructor takes an rvalue reference to indicate that it should be called with expressions that can be assigned or passed by value without creating a new temporary object, such as variables that are about to go out of scope or function return values. Taking an rvalue reference allows the move constructor to optimize the transfer of resources from one object to another by avoiding unnecessary copying.

What is the difference between a move constructor and a destructor?

A move constructor is used to move resources from one object to another during construction, while a destructor is responsible for cleaning up any resources allocated by an object before it is destroyed. Move constructors are called during the construction of an object, while destructors are called when the object goes out of scope or is explicitly