Using a good quality C++ Editor actively helps you write better code and prompt you with tips on how to use the various capabilities of the C++ standards. One of the features of modern C++ is the move constructor that allows you to move the resources from one object to another object without copying them. In this post, we explain what a typical declaration of a move constructor is.
First, let’s remember what are the classes and objects in C++.
Table of Contents
What are classes and objects in C++?
Classes are defined in C++ using keyword class followed by the name of the class. Classes are the blueprint for the objects, and they are user-defined data types that we can use in our program, and they work as an object constructor. Objects are an instantiation of a class. In C++ programming, most of the commands are associated with classes and objects, along with their attributes and methods. Here is a simple class example below.
|
1 2 3 4 5 6 7 |
class Tmyclass { public: std::string str; }; |
then we can create our objects with this Type of myclass as below,
|
1 2 3 |
Tmyclass o1, o2; |
Now, lets see what is move constructor,
What is a move constructor in modern C++?
The move constructor is a constructor that allows you to move the resources from one object to another object without copying them. In other terms, the move constructor allows you to move the resources from an rvalue object into to an lvalue object.
The move constructor is used to move data of one object to the new one, it is a kind of to make a new pointer to the members of an old object and transfers the resources to the heap memory. When you move a member, if the data member is a pointer, you should also set the value of the member of the old object to a NULL value. When you use the move constructor, you don’t use unnecessary data copying in the memory. This allows you to create objects faster. Mostly, if your class/object has a move constructor, you can use other move methods of other features of C++, for example, std::vector, std::array, std::map, etc. For example, you can create a vector with your class type then you can use the push_back() method that runs your move constructor.
Here is the most common syntax for the move constructor in C++.
|
1 2 3 |
class_name ( class_name && ) |
this general syntax is also a syntax for the “Typical declaration of a move constructor” as below.
|
1 2 3 4 5 |
class_name ( class_name && ) // Declaration { // Definition } // Definition |
What is a typical declaration of a move constructor?
The typical declaration of a move constructor is a move constructor declaration method that has user defined declaration and definition parts, and this is how you can declare typical move constructor in a class.
|
1 2 3 4 5 6 7 8 9 10 11 |
class Tx { public: Tx() = default; // Default Constructor Tx(Tx&& other) // A Typical Declaration of a Move Constructor { } } |
As given here above, if you have a move constructor, you should define a Constructor too, otherwise you will have “No matching constructor for initialization of class” error in compilation.
In modern C++, a simple class as below has all five special members (copy constructor, copy assignment, move constructor, move assignment, destructor)
|
1 2 3 4 5 6 |
class Tx { }; |
If you have any of them, you should define all five of them (Rule of Five) including the move constructor too. Note that the move constructor as shown in the simple class here is the default move constructor.
Is there a simple example of a typical declaration of a move constructor in modern C++?
Here is a simple example of a typical move constructor declaration.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
class Tx { public: std::string str; Tx() // Constructor { } Tx(Tx&& other) // Typical Declaration of a Move Constructor { str =std::move(other.str); // Moving string with std::move } }; |
We can use move constructor with std::move as in example below.
|
1 2 3 4 |
class Tx o1; class Tx o2 = std::move(o1); // Using Move Constructor with std::move |
Is there a full example of a typical declaration of a move constructor in modern C++?
Here is a full example of a C++ move constructor, where one object is moved to another one.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
#include <iostream> #include <vector> #include <string> class Tx { public: std::string str; Tx() // Constructor { } Tx(Tx&& other) // Typical Declaration of a Move Constructor { str =std::move(other.str); // Moving string with std::move } }; int main() { class Tx o1; o1.str = "LearnCPlusPlus.org"; class Tx o2 = std::move(o1); // Using Move Constructor std::cout << o2.str << std::endl; std::cout << o1.str << std::endl; system("pause"); return 0; } |
The outputs of str of o2 and o1 will be as follows,
|
1 2 3 4 5 |
LearnCPlusPlus.org Press any key to continue . . . |
Why should I follow the rule of five if there is a move constructor?
In C++, The Rule of Five states that if a type ever needs one of the following special members, then it must have all of the five special members.
- Copy constructor
- Copy assignment
- Move constructor
- Move assignment
- Destructor
In other words, if you have a move constructor in a class, you should carefully define all of them in accordance with your data members (properties).
Note that, a simple empty C++ class is perfectly equivalent to default implementations (Rule of Five) in a class. A modern compiler is able to provide all these special member functions (default implementations). For example, this simple class below
|
1 2 3 4 5 6 |
class Tx { }; |
is exactly the same as the one below in modern C++.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
class Tx { public: Tx() = default; // constructor Tx(Tx const& other) = default; // copy constructor Tx& operator=(Tx const& other) = default; // copy assignment operator Tx(Tx&& other) = default; // move constructor Tx& operator=(Tx&& other) = default; // move assignment operator ~Tx() = default; // destructor }; |
If you need more technical details about the move constructor, it is explained by Bjarne Stroustrup and Lawrence Crowlcan in this publication here; https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html
As you see in modern C++ these 5 special members are automatically generated as a default for each new class. If you have a special member of one of these, you must define all of them as in Rule of Five.
C++ Builder is the easiest and fastest C and C++ IDE for building simple or professional applications on the Windows, MacOS, iOS & Android operating systems. It is also easy for beginners to learn with its wide range of samples, tutorials, help files, and LSP support for code. RAD Studio’s C++ Builder version comes with the award-winning VCL framework for high-performance native Windows apps and the powerful FireMonkey (FMX) framework for cross-platform UIs.
There is a free C++ Builder Community Edition for students, beginners, and startups; it can be downloaded from here. For professional developers, there are Professional, Architect, or Enterprise version.
Design. Code. Compile. Deploy.
Start Free Trial
Free C++Builder Community Edition
