move constructor move assignment operator

This browser is no longer supported.

Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.

Move Constructors and Move Assignment Operators (C++)

• 9 contributors

This topic describes how to write a move constructor and a move assignment operator for a C++ class. A move constructor enables the resources owned by an rvalue object to be moved into an lvalue without copying. For more information about move semantics, see Rvalue Reference Declarator: && .

This topic builds upon the following C++ class, MemoryBlock , which manages a memory buffer.

The following procedures describe how to write a move constructor and a move assignment operator for the example C++ class.

To create a move constructor for a C++ class

Define an empty constructor method that takes an rvalue reference to the class type as its parameter, as demonstrated in the following example:

In the move constructor, assign the class data members from the source object to the object that is being constructed:

Assign the data members of the source object to default values. This prevents the destructor from freeing resources (such as memory) multiple times:

To create a move assignment operator for a C++ class

Define an empty assignment operator that takes an rvalue reference to the class type as its parameter and returns a reference to the class type, as demonstrated in the following example:

In the move assignment operator, add a conditional statement that performs no operation if you try to assign the object to itself.

In the conditional statement, free any resources (such as memory) from the object that is being assigned to.

The following example frees the _data member from the object that is being assigned to:

Follow steps 2 and 3 in the first procedure to transfer the data members from the source object to the object that is being constructed:

Return a reference to the current object, as shown in the following example:

Example: Complete move constructor and assignment operator

The following example shows the complete move constructor and move assignment operator for the MemoryBlock class:

Example Use move semantics to improve performance

The following example shows how move semantics can improve the performance of your applications. The example adds two elements to a vector object and then inserts a new element between the two existing elements. The vector class uses move semantics to perform the insertion operation efficiently by moving the elements of the vector instead of copying them.

This example produces the following output:

Before Visual Studio 2010, this example produced the following output:

The version of this example that uses move semantics is more efficient than the version that does not use move semantics because it performs fewer copy, memory allocation, and memory deallocation operations.

Robust Programming

To prevent resource leaks, always free resources (such as memory, file handles, and sockets) in the move assignment operator.

To prevent the unrecoverable destruction of resources, properly handle self-assignment in the move assignment operator.

If you provide both a move constructor and a move assignment operator for your class, you can eliminate redundant code by writing the move constructor to call the move assignment operator. The following example shows a revised version of the move constructor that calls the move assignment operator:

The std::move function converts the lvalue other to an rvalue.

Rvalue Reference Declarator: && std::move

Was this page helpful?

Coming soon: Throughout 2024 we will be phasing out GitHub Issues as the feedback mechanism for content and replacing it with a new feedback system. For more information see: https://aka.ms/ContentUserFeedback .

Submit and view feedback for

Additional resources

22.3 — Move constructors and move assignment

Related content

You now have enough context to understand the key insight behind move semantics.

Automatic l-values returned by value may be moved instead of copied

cppreference.com

Move constructors.

A move constructor of class T is a non-template constructor whose first parameter is T && , const T && , volatile T && , or const volatile T && , and either there are no other parameters, or the rest of the parameters all have default values.

[ edit ] Syntax

Where class_name must name the current class (or current instantiation of a class template), or, when declared at namespace scope or in a friend declaration, it must be a qualified class name.

[ edit ] Explanation

• Typical declaration of a move constructor.
• Forcing a move constructor to be generated by the compiler.
• Avoiding implicit move constructor.

The move constructor is typically called when an object is initialized (by direct-initialization or copy-initialization ) from rvalue (xvalue or prvalue) (until C++17) xvalue (since C++17) of the same type, including

• initialization: T a = std :: move ( b ) ; or T a ( std :: move ( b ) ) ; , where b is of type T ;
• function argument passing: f ( std :: move ( a ) ) ; , where a is of type T and f is void f ( T t ) ;
• function return: return a ; inside a function such as T f ( ) , where a is of type T which has a move constructor.

When the initializer is a prvalue, the move constructor call is often optimized out (until C++17) never made (since C++17) , see copy elision .

Move constructors typically "steal" the resources held by the argument (e.g. pointers to dynamically-allocated objects, file descriptors, TCP sockets, I/O streams, running threads, etc.) rather than make copies of them, and leave the argument in some valid but otherwise indeterminate state. For example, moving from a std::string or from a std::vector may result in the argument being left empty. However, this behavior should not be relied upon. For some types, such as std::unique_ptr , the moved-from state is fully specified.

[ edit ] Implicitly-declared move constructor

If no user-defined move constructors are provided for a class type ( struct , class , or union ), and all of the following is true:

• there are no user-declared copy constructors ;
• there are no user-declared copy assignment operators ;
• there are no user-declared move assignment operators ;
• there are no user-declared destructors ;

then the compiler will declare a move constructor as a non- explicit inline public member of its class with the signature T::T(T&&) .

A class can have multiple move constructors, e.g. both T :: T ( const T && ) and T :: T ( T && ) . If some user-defined move constructors are present, the user may still force the generation of the implicitly declared move constructor with the keyword default .

The implicitly-declared (or defaulted on its first declaration) move constructor has an exception specification as described in dynamic exception specification (until C++17) exception specification (since C++17)

[ edit ] Deleted implicitly-declared move constructor

The implicitly-declared or defaulted move constructor for class T is defined as deleted if any of the following is true:

• T has non-static data members that cannot be moved (have deleted, inaccessible, or ambiguous move constructors);
• T has direct or virtual base class that cannot be moved (has deleted, inaccessible, or ambiguous move constructors);
• T has direct or virtual base class with a deleted or inaccessible destructor;
• T is a union-like class and has a variant member with non-trivial move constructor;

[ edit ] Trivial move constructor

The move constructor for class T is trivial if all of the following is true:

• it is not user-provided (meaning, it is implicitly-defined or defaulted);
• T has no virtual member functions;
• T has no virtual base classes;
• the move constructor selected for every direct base of T is trivial;
• the move constructor selected for every non-static class type (or array of class type) member of T is trivial;

A trivial move constructor is a constructor that performs the same action as the trivial copy constructor, that is, makes a copy of the object representation as if by std::memmove . All data types compatible with the C language (POD types) are trivially movable.

[ edit ] Implicitly-defined move constructor

If the implicitly-declared move constructor is neither deleted nor trivial, it is defined (that is, a function body is generated and compiled) by the compiler if odr-used . For union types, the implicitly-defined move constructor copies the object representation (as by std::memmove ). For non-union class types ( class and struct ), the move constructor performs full member-wise move of the object's bases and non-static members, in their initialization order, using direct initialization with an xvalue argument. If this satisfies the requirements of a constexpr constructor , the generated move constructor is constexpr .

[ edit ] Notes

To make strong exception guarantee possible, user-defined move constructors should not throw exceptions. For example, std::vector relies on std::move_if_noexcept to choose between move and copy when the elements need to be relocated.

If both copy and move constructors are provided and no other constructors are viable, overload resolution selects the move constructor if the argument is an rvalue of the same type (an xvalue such as the result of std::move or a prvalue such as a nameless temporary (until C++17) ), and selects the copy constructor if the argument is an lvalue (named object or a function/operator returning lvalue reference). If only the copy constructor is provided, all argument categories select it (as long as it takes a reference to const, since rvalues can bind to const references), which makes copying the fallback for moving, when moving is unavailable.

A constructor is called a 'move constructor' when it takes an rvalue reference as a parameter. It is not obligated to move anything, the class is not required to have a resource to be moved and a 'move constructor' may not be able to move a resource as in the allowable (but maybe not sensible) case where the parameter is a const rvalue reference (const T&&).

[ edit ] Example

• Recent changes
• Offline version
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• Page information
• In other languages
• This page was last modified on 18 February 2019, at 03:43.
• This page has been accessed 606,979 times.
• Privacy policy
• About cppreference.com
• Disclaimers

• Analysis of Algorithms
• Backtracking
• Dynamic Programming
• Divide and Conquer
• Geometric Algorithms
• Mathematical Algorithms
• Pattern Searching
• Bitwise Algorithms
• Branch & Bound
• Randomized Algorithms

std::move in Utility in C++ | Move Semantics, Move Constructors and Move Assignment Operators

• Copy Constructor vs Assignment Operator in C++
• How to Implement Move Assignment Operator in C++?
• Default Assignment Operator and References in C++
• Move Assignment Operator in C++ 11
• How to Create Custom Assignment Operator in C++?
• Self assignment check in assignment operator
• std::is_trivially_copy_assignable class in C++ with Examples
• std::is_copy_constructible in C++ with Examples
• Inserting elements in std::map (insert, emplace and operator [])
• std::is_nothrow_move_constructible in C++ with Example
• std::istream_iterator and std::ostream_iterator in C++ STL
• How to Implement a Copy Constructor in a Derived Class in C++
• Increment Operator Behavior When Passed as Function Parameters in C++
• Operator Overloading '<<' and '>>' operator in a linked list class
• std::is_trivially_move_constructible in C++ with Examples
• std::transform() in C++ STL (Perform an operation on all elements)
• How to Convert a Vector to a List Without Losing Element Order in C++?
• Increment (++) and Decrement (--) Operator Overloading in C++
• Difference Between Constructor and Destructor in C++

Prerequisites:

• lvalue reference
• rvalue reference
• Copy Semantics (Copy Constructor)

References:

In C++ there are two types of references-

• An lvalue is an expression that will appear on the left-hand side or on the right-hand side of an assignment.
• Simply, a variable or object that has a name and memory address.
• It uses one ampersand (&).
• An rvalue is an expression that will appear only on the right-hand side of an assignment.
• A variable or object has only a memory address (temporary objects).
• It uses two ampersands (&&).

Move Constructor And Semantics:

The move constructor was introduced in C++11 . The need or purpose of a move constructor is to steal or move as many resources as it can from the source (original) object , as fast as possible, because the source does not need to have a meaningful value anymore, and/or because it is going to be destroyed in a moment anyway. So that one can avoid unnecessarily creating copies of an object and make efficient use of the resources

While one can steal the resources, but one must leave the source (original) object in a valid state where it can be correctly destroyed.

Move constructors typically “steal” the resource of the source (original) object rather than making several copies of them, and leaves the source object in a “valid but unspecified state”.

The copy constructor uses the lvalue references which are marked with one ampersand (&) while the move constructor uses the rvalue references are marked with two ampersands (&&).

std::move() is a function used to convert an lvalue reference into the rvalue reference. Used to move the resources from a source object i.e. for efficient transfer of resources from one object to another. std::move() is defined in the <utility> header .

template< class T >  typename std::remove_reference<T>::type&& move(T&& t) noexcept;                 (since C++11)(until C++14) template< class T >  constexpr std::remove_reference_t<T>&& move(T&& t) noexcept                       (since C++14)

Example: Below is the C++ program to show what happens without using move semantics i.e. before C++11.

Explanation:

Assuming the program is compiled and executed using a compiler that doesn’t support move semantics. In the main() function,  

1. std::vector<std::string> vecString;- An empty vector is created with no elements in it.  2. vecString = createAndInsert();- The createAndInsert() function is called. 3. In createAndInsert() function-

• std::vector<std::string> vec;- Another new empty vector named as vec is created.
• vec.reserve(3);- Reserving the size of 3 elements.
• std::string str(“Hello”);- A string named as str initialized with a “Hello”.
• vec.push_back( str );- A string is passed by value into the vector vec. Therefore a (deep) copy of str will be created and inserted into the vec by calling a copy constructor of the String class.
• A temporary object will be created (str + str) with its own separate memory.
• This temporary object is inserted into vector vec which is passed by value again means that a (deep) copy of the temporary string object will be created.
• As of now, the temporary object is no longer needed hence it will be destroyed.

Note: Here, we unnecessarily allocate & deallocate the memory of the temporary string object. which can be optimized (improved) further just by moving the data from the source object. 

• vec.push_back( str );- The same process as of Line no. 5 will be carried out. Remember at this point the str string object will be last used.
• Firstly, the string object str will be destroyed because the scope is left where it is declared.
• Secondly, a local vector of string i.e vec is returned. As the return type of the function is not by a reference. Hence, a deep copy of the whole vector will be created by allocating at a separate memory location and then destroys the local vec object because the scope is left where it is declared.
• Finally, the copy of the vector of strings will be returned to the caller main() function.
• At the last, after returning to the caller main() function, simply printing the elements of the local vecString vector.

Example: Below is the C++ program to implement the above concept using move semantics i.e. since C++11 and later. 

Here, in order to use the move semantics. The compiler must support the C++11 standards or above. The story of execution for the main() function and createAndInsert() function remains the same till the line vec.push_back( str );

A question may arise why the temporary object is not moved to vector vec using std::move(). The reason behind it is the push_back() method of the vector. Since C++11 the push_back() method has been provided with its new overloaded version.

Syntax:  

constexpr void push_back(const T& value);                                        (since C++20) void push_back(T&& value);                                                              (since C++11) (until C++20) void push_back(const T& value);                                                        (until C++20) constexpr void push_back(T&& value);                                              (since C++20)

• A temporary object will be created (str + str) with its own separate memory and will make a call to overloaded push_back() method (version 2nd  or 4th depends on the version of C++) which will steal (or moved) the data from the temporary source object (str + str) to the vector vec as it is no longer required.
• After performing the move the temporary object gets destroyed. Thus rather than calling the copy constructor (copy semantics), it is optimized just by copying the size of the string and manipulating pointers to the memory of the data.
• Here, the important point to note is that we make use of the memory which will soon no longer owns its memory. In another word, we somehow optimized it. That’s all because of the rvalue reference and move semantics.
• vec.push_back(std::move(str));- Here the compiler is explicitly hinted that “object is no longer needed” named as str ( lvalue reference ) with the help of std::move() function by converting the lvalue reference into rvalue reference and the resource of the str will be moved to the vector. Then the state of str becomes a “valid but unspecified state”. This doesn’t matter to us because for the last time we are going to use and soon be destroyed in a moment anyway.
• Lastly, return the local vector of string called vec to its caller.
• In the end, returned to the caller main() function, and simply printing the elements of the local vecString vector.

A question may arise while returning the vec object to its caller. As it is not required anymore and also a whole temporary object of a vector is going to be created and also local vector vec will be destroyed, then why std::move() is not used to steal the value and return it.  Its answer is simple and obvious, there is optimization at the compiler level known as (Named) Return Value Object, more popularly known as RVO . 

Some Fallback Of Move Semantics:  

• It doesn’t make any sense to steal or move the resources of a const object.
• See constObjectCallFunc() function in the below program
• See baz() function in the below program
• See bar() function in the below program

Note: The foo() function have all necessary types of arguments.

Below is the C++ program to implement all the above concepts- 

Summary:  

• Move semantics allows us to optimize the copying of objects, where we do not need the worth. It is often used implicitly (for unnamed temporary objects or local return values) or explicitly with std::move().
• std::move() means “no longer need this value” .
• An object marked with std::move() is never partially destroyed. i.e. The destructor will be called to destroy the object properly.

Please Login to comment...

Similar reads.

• Blogathon-2021
• Constructors
• C++ Programs
• Competitive Programming

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Move assignment operator

A move assignment operator of class T is a non-template non-static member function with the name operator = that takes exactly one parameter of type T && , const T && , volatile T && , or const volatile T && . A type with a public move assignment operator is MoveAssignable .

[ edit ] Syntax

[ edit ] Explanation

• Typical declaration of a move assignment operator
• Forcing a move assignment operator to be generated by the compiler
• Avoiding implicit move assignment

The move assignment operator is called whenever it is selected by overload resolution , e.g. when an object appears on the left side of an assignment expression, where the right-hand side is an rvalue of the same or implicitly convertible type.

Move assignment operators typically "steal" the resources held by the argument (e.g. pointers to dynamically-allocated objects, file descriptors, TCP sockets, I/O streams, running threads, etc), rather than make copies of them, and leave the argument in some valid but otherwise indeterminate state. For example, move-assigning from a std:: string or from a std:: vector leaves the right-hand side argument empty.

[ edit ] Implicitly-declared move assignment operator

If no user-defined move assignment operators are provided for a class type ( struct , class , or union ), and all of the following is true:

• there are no user-declared copy constructors
• there are no user-declared move constructors
• there are no user-declared copy assignment operators
• there are no user-declared destructors
• the implicitly-declared move assignment operator would not be defined as deleted

then the compiler will declare a move assignment operator as an inline public member of its class with the signature T& T::operator= T(T&&)

A class can have multiple move assignment operators, e.g. both T & T :: operator = ( const T && ) and T & T :: operator = ( T && ) . If some user-defined move assignment operators are present, the user may still force the generation of the implicitly declared move assignment operator with the keyword default .

Because some assignment operator (move or copy) is always declared for any class, the base class assignment operator is always hidden. If a using-declaration is used to bring in the assignment operator from the base class, and its argument type could be the same as the argument type of the implicit assignment operator of the derived class, the using-declaration is also hidden by the implicit declaration.

[ edit ] Deleted implicitly-declared move assignment operator

The implicitly-declared or defaulted move assignment operator for class T is defined as deleted in any of the following is true:

• T has a non-static data member that is const
• T has a non-static data member of a reference type.
• T has a non-static data member that cannot be move-assigned (has deleted, inaccessible, or ambiguous move assignment operator)
• T has direct or virtual base class that cannot be move-assigned (has deleted, inaccessible, or ambiguous move assignment operator)
• T has a non-static data member or a direct or virtual base without a move assignment operator that is not trivially copyable.
• T has a direct or indirect virtual base class

[ edit ] Trivial move assignment operator

The implicitly-declared move assignment operator for class T is trivial if all of the following is true:

• T has no virtual member functions
• T has no virtual base classes
• The move assignment operator selected for every direct base of T is trivial
• The move assignment operator selected for every non-static class type (or array of class type) memeber of T is trivial

A trivial move assignment operator performs the same action as the trivial copy assignment operator, that is, makes a copy of the object representation as if by std:: memmove . All data types compatible with the C language (POD types) are trivially move-assignable.

[ edit ] Implicitly-defined move assignment operator

If the implicitly-declared move assignment operator is not deleted or trivial, it is defined (that is, a function body is generated and compiled) by the compiler. For union types, the implicitly-defined move assignment operator copies the object representation (as by std:: memmove ). For non-union class types ( class and struct ), the move assignment operator performs full member-wise move assignment of the object's bases and non-static members, in their initialization order, using built-in assignment for the scalars and move assignment operator for class types.

[ edit ] Notes

If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is an rvalue (either prvalue such as a nameless temporary or xvalue such as the result of std:: move ), and selects the copy assignment if the argument is lvalue (named object or a function/operator returning lvalue reference). If only the copy assignment is provided, all argument categories select it (as long as it takes its argument by value or as reference to const, since rvalues can bind to const references), which makes copy assignment the fallback for move assignment, when move is unavailable.

The copy-and-swap assignment operator

T & T :: operator = ( T arg ) {     swap ( arg ) ;     return * this ; }

performs an equivalent of move assignment for rvalue arguments at the cost of one additional call to the move constructor of T, which is often acceptable.

[ edit ] Example

cppreference.com

Move constructors

A move constructor of class T is a non-template constructor whose first parameter is T && , const T && , volatile T && , or const volatile T && , and either there are no other parameters, or the rest of the parameters all have default values. A type with a public move constructor is MoveConstructible .

[ edit ] Syntax

[ edit ] Explanation

• Typical declaration of a move constructor
• Forcing a move constructor to be generated by the compiler
• Avoiding implicit move constructor

The move constructor is called whenever an object is initialized from xvalue of the same type, which includes

• initialization, T a = std:: move ( b ) ; or T a ( std:: move ( b ) ) ; , where b is of type T
• function argument passing: f ( std:: move ( a ) ) ; , where a is of type T and f is void f ( T t )
• function return: return a ; inside a function such as T f ( ) , where a is of type T which has a move constructor.

Move constructors typically "steal" the resources held by the argument (e.g. pointers to dynamically-allocated objects, file descriptors, TCP sockets, I/O streams, running threads, etc), rather than make copies of them, and leave the argument in some valid but otherwise indeterminate state. For example, moving from a std:: string or from a std:: vector turns the argument empty.

[ edit ] Implicitly-declared move constructor

If no user-defined move constructors are provided for a class type ( struct , class , or union ), and all of the following is true:

• there are no user-declared copy constructors
• there are no user-declared copy assignment operators
• there are no user-declared move assignment operators
• there are no user-declared destructurs
• the implicitly-declared move constructor would not be defined as deleted

then the compiler will declare a move constructor as an inline public member of its class with the signature T::T(T&&)

A class can have multiple move constructors, e.g. both T :: T ( const T && ) and T :: T ( T && ) . If some user-defined move constructors are present, the user may still force the generation of the implicitly declared move constructor with the keyword default .

[ edit ] Deleted implicitly-declared move constructor

The implicitly-declared or defaulted move constructor for class T is defined as deleted in any of the following is true:

• T has non-static data members that cannot be moved (have deleted, inaccessible, or ambiguous move constructors)
• T has direct or virtual base class that cannot be moved (has deleted, inaccessible, or ambiguous move constructors)
• T has direct or virtual base class with a deleted or inaccessible destructor
• T has a user-defined move constructor or move assignment operator
• T is a union and has a variant member with non-trivial copy constructor
• T has a non-static data member or a direct or virtual base without a move constructor that is not trivially copyable.

[ edit ] Trivial move constructor

The implicitly-declared move constructor for class T is trivial if all of the following is true:

• T has no virtual member functions
• T has no virtual base classes
• The move constructor selected for every direct base of T is trivial
• The move constructor selected for every non-static class type (or array of class type) memeber of T is trivial

A trivial move constructor is a constructor that performs the same action as the trivial copy constructor, that is, makes a copy of the object representation as if by std:: memmove . All data types compatible with the C language (POD types) are trivially movable.

[ edit ] Implicitly-defined move constructor

If the implicitly-declared move constructor is not deleted or trivial, it is defined (that is, a function body is generated and compiled) by the compiler. For union types, the implicitly-defined move constructor copies the object representation (as by std:: memmove ). For non-union class types ( class and struct ), the move constructor performs full member-wise move of the object's bases and non-static members, in their initialization order, using direct initialization with an xvalue argument.

[ edit ] Notes

To make strong exception guarantee possible, user-defined move constructors should not throw exceptions. In fact, standard containers typically rely on std:: move_if_noexcept to choose between move and copy when container elements need to be relocated.

If both copy and move constructors are provided, overload resolution selects the move constructor if the argument is an rvalue (either prvalue such as a nameless temporary or xvalue such as the result of std:: move ), and selects the copy constructor if the argument is lvalue (named object or a function/operator returning lvalue reference). If only the copy constructor is provided, all argument categories select it (as long as it takes reference to const, since rvalues can bind to const references), which makes copying the fallback for moving, when moving is unavailable.

[ edit ] Example

• Recent changes
• Offline version
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• This page was last modified on 15 June 2012, at 14:13.
• This page has been accessed 46 times.
• Privacy policy
• About cppreference.com
• Disclaimers

Move assignment operator

A move assignment operator of class T is a non-template non-static member function with the name operator = that takes exactly one parameter of type T && , const T && , volatile T && , or const volatile T && .

Explanation

• Typical declaration of a move assignment operator.
• Forcing a move assignment operator to be generated by the compiler.
• Avoiding implicit move assignment.

The move assignment operator is called whenever it is selected by overload resolution , e.g. when an object appears on the left-hand side of an assignment expression, where the right-hand side is an rvalue of the same or implicitly convertible type.

Move assignment operators typically "steal" the resources held by the argument (e.g. pointers to dynamically-allocated objects, file descriptors, TCP sockets, I/O streams, running threads, etc.), rather than make copies of them, and leave the argument in some valid but otherwise indeterminate state. For example, move-assigning from a std::string or from a std::vector may result in the argument being left empty. This is not, however, a guarantee. A move assignment is less, not more restrictively defined than ordinary assignment; where ordinary assignment must leave two copies of data at completion, move assignment is required to leave only one.

Implicitly-declared move assignment operator

If no user-defined move assignment operators are provided for a class type ( struct , class , or union ), and all of the following is true:

• there are no user-declared copy constructors;
• there are no user-declared move constructors;
• there are no user-declared copy assignment operators;
• there are no user-declared destructors;

then the compiler will declare a move assignment operator as an inline public member of its class with the signature T& T::operator=(T&&) .

A class can have multiple move assignment operators, e.g. both T & T :: operator = ( const T && ) and T & T :: operator = ( T && ) . If some user-defined move assignment operators are present, the user may still force the generation of the implicitly declared move assignment operator with the keyword default .

The implicitly-declared (or defaulted on its first declaration) move assignment operator has an exception specification as described in dynamic exception specification (until C++17) exception specification (since C++17)

Because some assignment operator (move or copy) is always declared for any class, the base class assignment operator is always hidden. If a using-declaration is used to bring in the assignment operator from the base class, and its argument type could be the same as the argument type of the implicit assignment operator of the derived class, the using-declaration is also hidden by the implicit declaration.

Deleted implicitly-declared move assignment operator

The implicitly-declared or defaulted move assignment operator for class T is defined as deleted if any of the following is true:

• T has a non-static data member that is const ;
• T has a non-static data member of a reference type;
• T has a non-static data member that cannot be move-assigned (has deleted, inaccessible, or ambiguous move assignment operator);
• T has direct or virtual base class that cannot be move-assigned (has deleted, inaccessible, or ambiguous move assignment operator);

Trivial move assignment operator

The move assignment operator for class T is trivial if all of the following is true:

• It is not user-provided (meaning, it is implicitly-defined or defaulted);
• T has no virtual member functions;
• T has no virtual base classes;
• the move assignment operator selected for every direct base of T is trivial;
• the move assignment operator selected for every non-static class type (or array of class type) member of T is trivial;

A trivial move assignment operator performs the same action as the trivial copy assignment operator, that is, makes a copy of the object representation as if by std::memmove . All data types compatible with the C language (POD types) are trivially move-assignable.

Implicitly-defined move assignment operator

If the implicitly-declared move assignment operator is neither deleted nor trivial, it is defined (that is, a function body is generated and compiled) by the compiler if odr-used .

For union types, the implicitly-defined move assignment operator copies the object representation (as by std::memmove ).

For non-union class types ( class and struct ), the move assignment operator performs full member-wise move assignment of the object's direct bases and immediate non-static members, in their declaration order, using built-in assignment for the scalars, memberwise move-assignment for arrays, and move assignment operator for class types (called non-virtually).

If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is an rvalue (either a prvalue such as a nameless temporary or an xvalue such as the result of std::move ), and selects the copy assignment if the argument is an lvalue (named object or a function/operator returning lvalue reference). If only the copy assignment is provided, all argument categories select it (as long as it takes its argument by value or as reference to const, since rvalues can bind to const references), which makes copy assignment the fallback for move assignment, when move is unavailable.

It is unspecified whether virtual base class subobjects that are accessible through more than one path in the inheritance lattice, are assigned more than once by the implicitly-defined move assignment operator (same applies to copy assignment ).

See assignment operator overloading for additional detail on the expected behavior of a user-defined move-assignment operator.

cppreference.com

Move constructors

A move constructor of class T is a non-template constructor whose first parameter is T && , const T && , volatile T && , or const volatile T && , and either there are no other parameters, or the rest of the parameters all have default values.

[ edit ] Syntax

[ edit ] Explanation

• Typical declaration of a move constructor
• Forcing a move constructor to be generated by the compiler
• Avoiding implicit move constructor

The move constructor is called whenever an object is initialized from xvalue of the same type, which includes

• initialization, T a = std :: move ( b ) ; or T a ( std :: move ( b ) ) ; , where b is of type T
• function argument passing: f ( std :: move ( a ) ) ; , where a is of type T and f is void f ( T t )
• function return: return a ; inside a function such as T f ( ) , where a is of type T which has a move constructor.

Move constructors typically "steal" the resources held by the argument (e.g. pointers to dynamically-allocated objects, file descriptors, TCP sockets, I/O streams, running threads, etc), rather than make copies of them, and leave the argument in some valid but otherwise indeterminate state. For example, moving from a std::string or from a std::vector may result in the argument being left empty. However, this behaviour should not be relied upon.

[ edit ] Implicitly-declared move constructor

If no user-defined move constructors are provided for a class type ( struct , class , or union ), and all of the following is true:

• there are no user-declared copy constructors
• there are no user-declared copy assignment operators
• there are no user-declared move assignment operators
• there are no user-declared destructors
• (until C++14) the implicitly-declared move constructor is not defined as deleted due to conditions detailed in the next section

then the compiler will declare a move constructor as a non- explicit inline public member of its class with the signature T::T(T&&) .

A class can have multiple move constructors, e.g. both T :: T ( const T && ) and T :: T ( T && ) . If some user-defined move constructors are present, the user may still force the generation of the implicitly declared move constructor with the keyword default .

[ edit ] Deleted implicitly-declared move constructor

The implicitly-declared or defaulted move constructor for class T is defined as deleted in any of the following is true:

• T has non-static data members that cannot be moved (have deleted, inaccessible, or ambiguous move constructors)
• T has direct or virtual base class that cannot be moved (has deleted, inaccessible, or ambiguous move constructors)
• T has direct or virtual base class with a deleted or inaccessible destructor
• T is a union and has a variant member with non-trivial copy constructor
• (until C++14) T has a non-static data member or a direct or virtual base without a move constructor that is not trivially copyable.

(since C++14) The deleted implicitly-declared move constructor is ignored by overload resolution (otherwise it would prevent copy-initialization from rvalue)

[ edit ] Trivial move constructor

The move constructor for class T is trivial if all of the following is true:

• It is not user-provided (meaning, it is implicitly-defined or defaulted), and if it is defaulted, its signature is the same as implicitly-defined
• T has no virtual member functions
• T has no virtual base classes
• The move constructor selected for every direct base of T is trivial
• The move constructor selected for every non-static class type (or array of class type) member of T is trivial

A trivial move constructor is a constructor that performs the same action as the trivial copy constructor, that is, makes a copy of the object representation as if by std::memmove . All data types compatible with the C language (POD types) are trivially movable.

[ edit ] Implicitly-defined move constructor

If the implicitly-declared move constructor is neither deleted nor trivial, it is defined (that is, a function body is generated and compiled) by the compiler if odr-used . For union types, the implicitly-defined move constructor copies the object representation (as by std::memmove ). For non-union class types ( class and struct ), the move constructor performs full member-wise move of the object's bases and non-static members, in their initialization order, using direct initialization with an xvalue argument.

[ edit ] Notes

To make strong exception guarantee possible, user-defined move constructors should not throw exceptions. In fact, standard containers typically rely on std::move_if_noexcept to choose between move and copy when container elements need to be relocated.

If both copy and move constructors are provided, overload resolution selects the move constructor if the argument is an rvalue (either prvalue such as a nameless temporary or xvalue such as the result of std::move ), and selects the copy constructor if the argument is lvalue (named object or a function/operator returning lvalue reference). If only the copy constructor is provided, all argument categories select it (as long as it takes reference to const, since rvalues can bind to const references), which makes copying the fallback for moving, when moving is unavailable.

In many situations, move constructors are optimized out even if they would produce observable side-effects, see copy elision

A constructor is called a 'move constructor' when it takes an rvalue reference as a parameter. It is not obligated to move anything, the class is not required to have a resource to be moved and a 'move constructor' may not be able to move a resource as in the allowable (but maybe not sensible) case where the parameter is a const rvalue reference (const T&&).

[ edit ] Example

• Recent changes
• Offline version
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• Page information
• In other languages
• This page was last modified on 29 November 2015, at 15:51.
• This page has been accessed 168,237 times.
• Privacy policy
• About cppreference.com
• Disclaimers

Stack Exchange Network

Stack Exchange network consists of 183 Q&A communities including Stack Overflow , the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Vector with move constructor and move assignment operator [closed]

Please verify whether the code for a move constructor and a move assignment operator is correct.

• memory-management

• \$\begingroup\$ This isn't that kind of code review; take the tour , see How to Ask . If you aren't certain it works, test it. \$\endgroup\$ –  jonrsharpe Apr 2, 2017 at 8:54

Default constructor

Stop trying to save space like that. THe point of good coding is to make it readable by humans. The computer can read any style so try and make it more maintainable by making it readable.

I would write it like this:

Sure you can use nullptr for the zero sized array. But this seems like a premature optimization. You can make the rest of your code less complicated by never having a null m_pInt . If there is never a null then your code does not need to check for it.

Also currently you have different behavior for:

Constructor

Sure this works. But std::cout is not the only stream you way want to print too

So I would pass a stream to print() . It can default to std::cout . Then you should add an operator<< . As the normal way of printing something is via << .

Note: prefer "\n" to std::endl . The difference is a stream flush. The stream will already flush itself when required. So you adding extra flushes is only going to cause the flushes to be less optimal.

Copy Constructor

Move constructor.

Yes that works. But you should also mark the move constructor as noexcept . The standard containers have optimizations that can be applied if they know tour class will not throw when being moved. Otherwise they have to fallback to copying to provide the strong exception guarantee.

The standard technique is to use swap though. It makes it look and behave just like move assignment. See below.

Copy Assignment

Yes the test for self assignment looks like a good optimization.

BUT its not. Self assignment happens so rarely (in fact basically never in real code) that what you are doing is pesimizing the normal flow and as a result will make your code slower. You do need to cope with self assignment but because it is so rare you don't need to worry that it is not the optimal path.

The second issue I have here is that you destroy the local data before you have a copy of the new data ready.

If something goes wrong in the rest of your code then you will be unable to roll back the state and thus can not provide the strong exception guarantee. When copying an object it should happen in three distict phases.

So your Copy assignment should look like this:

If you look carefully at those three stages. Stage 1 looks like the constructor and stage 3 looks like the destructor and stage 2 looks like a standard swap function so we can simplify the above to exactly that:

This is called the copy and swap idiom.

Move Assignment

Again the pesimizing test for self assignment.

The standard move assignment is to swap the source and the destination. This has a couple of benefits.

• You don't call delete (and thus don't invoke the destructor). Thus it is potentially faster.
• Because you did not delete the data there is an opportunity for it to be reused.
• If the source is going out of scope it will invoke its destructor and destroy your data but it will be done after the completion of your object thus giving you strong exception guarantee. Thus allowing you to make your assignment operator noexcept.

Standard Move Assignment

I wrote a series of posts about all this.

Vector - Resource Management Allocation Vector - Resource Management Copy Swap Vector - Resize Vector - Simple Optimizations Vector - the Other Stuff

• \$\begingroup\$ Hi. What do you mean by "Stop trying to save space like that." regarding the code MyVector():m_Size(0), m_pInt(nullptr) { } ? What would you write instead if this was the only constructor? \$\endgroup\$ –  krismath May 1, 2017 at 21:20
• 2 \$\begingroup\$ @krismath: One initialization per line. The point is to write readable code not try and squeeze as many operations onto a single line as you can. Updating answer with how I would write it. \$\endgroup\$ –  Martin York May 1, 2017 at 23:03
• \$\begingroup\$ MyVector() could be noexcept if you allow for m_pInt being nullptr . That's worth the hassle easily. \$\endgroup\$ –  Deduplicator May 1, 2017 at 23:16
• 1 \$\begingroup\$ @Deduplicator Not sure a noexcept default constructor buys you anything. Are there any optimizations in the STL this will enable? If it does not gain you anything then why add the extra complexity to the rest of your code. Especially when it adds two different meanings for basically the same declaration MyVector x; /* nullptr but size 0*/ and MyVector y(0); /* Not nullptr but size 0*/ \$\endgroup\$ –  Martin York May 1, 2017 at 23:31
• \$\begingroup\$ Fantastic answer. 1. I wonder why didn't you add m_pInt = nullptr in the destructor after deleting it. Omission? 2. In the ctor: MyVector(int x = 0) : m_size(0) . I believe you wanted to say m_size(x) here right? 3. I always tend to use {} instead of () for initialization of objects because it prevents widening and is more readable (doesn't look like a function call). \$\endgroup\$ –  KeyC0de Oct 19, 2018 at 3:47

Not the answer you're looking for? Browse other questions tagged c++ c++11 memory-management vectors or ask your own question .

Hot network questions.

• Movie I saw in the 80s where a substance oozed off of movie stairs leaving a wet cat behind
• Problems with dependent sums
• British child with Italian mother. Which document can she use to travel to/from Italy on her own?
• Has there ever been arms supply with restrictions attached prior to the current war in Ukraine?
• How to negotiate such toxic competitiveness during my master’s studies?
• How big can a chicken get?
• Word for a country declaring independence from an empire
• My players think they found a loophole that gives them infinite poison and XP. How can I add the proper challenges to slow them down?
• Is the B-theory of time only compatible with an infinitely renewing cyclical reality?
• Commutativity of the wreath product
• Smallest Harmonic number greater than N
• Brake Line no Longer Connected to Brake Lever
• Yosemite national park availability
• Thought experiment regarding gravity
• PolynomialQ behaviour
• What's the maximum amount of material that a puzzle with unique solution can have?
• Was it known in ancient Rome and Greece that boiling water made it safe to drink and if so, what was the theory behind this?
• Book where the populace is split between two sects, that of the “hand” and that of the “mind"
• Executable files with a bytecode compiler/interpreter
• Ubuntu Terminal with alternating colours for each line
• Why are ETFs so bad at tracking Japanese indices?
• is_decimal Function Implementation in C++
• Is there a phrase like "etymologically related" but for food?
• 1h 10m international > domestic transit at IST (Istanbul) on a single ticket

• Stack Overflow Public questions & answers
• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Talent Build your employer brand
• Advertising Reach developers & technologists worldwide
• Labs The future of collective knowledge sharing
• About the company

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

implement move constructor & move assignment operator in c++98 for better performance

Can I simulate move constructor & move assignment operator functionality with copy constructor and assignment operator in C++98 to improve the performance whenever i know copy constructor & copy assignment will be called only for temporary object in the code OR i am inserting needle in my eyes?

I have taken two example's one is normal copy constructor & copy assignment operator and other one simulating move constructor & move assignment operator and pushing 10000 elements in the vector to call copy constructor.

Example(copy.cpp) of normal copy constructor & copy assignment operator

Example(move.cpp) of simulated move constructor & move assignment operator functionality with copy constructor & copy assignment operator

I observed performance is improved with some cost:

We can observe that performance is increased with some cost.

• Has any pitfall to implement move constructor and move assignment operator simulated functionality in c++98, even I am sure that copy constructor & assignment only call when temporary objects are created?
• Has there any other way/technique to implement the move constructor and assignment operator in c++98?
• constructor
• copy-constructor

• 1 [OT]: delete null pointer is noop, so the check is unneeded. –  Jarod42 Jan 5, 2016 at 9:14
• 4 Dietmar Kühl talks about move semantics, including how to mimic the behaviour in C++98. –  BoBTFish Jan 5, 2016 at 9:17
• @ Jarod42, yes, length assignment i missed it. –  Ajay yadav Jan 5, 2016 at 9:23
• Your const-cast is Undefined Behaviour. Your "Move Constructor" has no idea if it has been handed an actually const instance of a Memory Block. std::auto_ptr has something similar to move semantics, and that involves dealing with a constructor taking a non-const reference to the object. –  Andre Kostur Jan 5, 2016 at 16:08
• @AndreKostur The assignment may have undefined behaviour. (It's definitely poor style and unsafe code.) The cast itself does not. –  Asteroids With Wings May 13, 2020 at 17:47

You will not be able to have the language understand R-values in the same way that C++11 and above will, but you can still approximate the behavior of move semantics by creating a custom "R-Value" type to simulate ownership transferring.

The Approach

"Move semantics" is really just destructively editing/stealing the contents from a reference to an object, in a form that is idiomatic. This is contrary to copying from immutable views to an object. The idiomatic approach introduced at the language level in C++11 and above is presented to us as an overload set, using l-values for copies ( const T& ), and (mutable) r-values for moves ( T&& ).

Although the language provides deeper hooks in the way that lifetimes are handled with r-value references, we can absolutely simulate the move-semantics in C++98 by creating an rvalue -like type, but it will have a few limitations. All we need is a way to create an overload set that can disambiguate the concept of copying, from the concept of moving.

Overload sets are nothing new to C++, and this is something that can be accomplished by a thin wrapper type that allows disambiguating overloads using tag-based dispatch.

For example:

We won't be able behave exactly like a reference by accessing members by the . operator, since that functionality does not exist in C++ -- hence having get() to get the reference. But we can signal a means that becomes idiomatic in the codebase to destructively alter types.

The rvalue type can be more creative based on whatever your needs are as well -- I just kept it simple for brevity. It might be worthwhile to add operator-> to at least have a way to directly access members.

I have left out T&& -> const T&& conversion, T&& to U&& conversion (where U is a base of T ), and T&& reference collapsing to T& . These things can be introduced by modifying rvalue with implicit conversion operators/constructors (but might require some light-SFINAE). However, I have found this rarely necessary outside of generic programming. For pure/basic "move-semantics", this is effectively sufficient.

Integrating it all together

Integrating this "rvalue" type is as simple as adding an overload for rvalue<T> where T is the type being "moved from". With your example above, it just requires adding a constructor / move assignment operator:

This allows you to keep copy constructors idiomatic, and simulate "move" constructors.

The use can now become:

Here's a working example on compiler explorer that compares the copy vs move assemblies.

Limitations

No pr-values to rvalue conversion.

The one notable limitation of this approach, is that you cannot do PR-value to R-value conversions that would occur in C++11 or above, like:

As far as I am aware, this cannot be replicated without language support.

No auto-generated move-constructors/assignment

Unlike C++11, there will be no auto-generated move constructors or assignment operators -- so this becomes a manual effort for types that you want to add "move" support to.

This is worth pointing out, since copy constructors and assignment operators come for free in some cases, whereas move becomes a manual effort.

An rvalue is not an L-value reference

In C++11, a named R-value reference is an l-value reference. This is why you see code like:

This named r-value to l-value conversion cannot be modeled without compiler support. This means that an rvalue reference will always behave like an R-value reference. E.g.:

So in short, you won't be able to have full language support for things like PR-values. But you can, at least, implement a means of allowing efficient moving of the contents from one type to another with a "best-effort" attempt. If this gets adopted unanimously in a codebase, it can become just as idiomatic as proper move-semantics in C++11 and above.

In my opinion, this "best-effort" is worth it despite the limitations listed above, since you can still transfer ownership more efficiently in an idiomatic manner.

Note: I do not recommend overloading both T& and const T& to attempt "move-semantics". The big issue here is that it can unintentionally become destructive with simple code, like:

This can cause buggy behavior in code, and is not easily visible. Using a wrapper approach at least makes this destruction much more explicit

• Example for your bootnote would be auto_ptr –  Asteroids With Wings May 13, 2020 at 17:36
• 2 I'm not sure who down-voted this solution, but care to provide an explanation so that I may address feedback? –  Human-Compiler May 13, 2020 at 17:48

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged c++ vector constructor copy-constructor c++98 or ask your own question .

• Featured on Meta
• The 2024 Developer Survey Is Live
• The return of Staging Ground to Stack Overflow
• The [tax] tag is being burninated
• Policy: Generative AI (e.g., ChatGPT) is banned

Hot Network Questions

• Can secondary dominant have 2 tritones with addition of b9?
• Does it make sense for giants to use clubs or swords when fighting non-giants?
• Do reflective warning triangles blow away in wind storms?
• How can show division of fraction with tikz?
• Having friends who are talented is great, but it can also be ___ at times
• In the Unabomber case, was "call Nathan R" really mistakenly written by a New York Times intern?
• What did the old woman say in "73 Yards"?
• Python script to auto change profiles in MSI Afterburner
• What's the maximum amount of material that a puzzle with unique solution can have?
• Is this deck post getting cracks due to overloaded?
• can you roll your own .iso for USB stick?
• Ubuntu Terminal with alternating colours for each line
• I need help in understanding the alternative solution provided to solve this geometry question of calculating area of quadrilateral
• Sum of square roots (as an algebraic number)
• Is cellulose, blown-in insulation biodegradeable?
• Book where the populace is split between two sects, that of the “hand” and that of the “mind"
• My players think they found a loophole that gives them infinite poison and XP. How can I add the proper challenges to slow them down?
• Why is array access not an infix operator?
• What rights do I have to improve upon patented inventions?
• What do humans do uniquely, that computers apparently will not be able to?
• What's the difference between cryogenic and Liquid propellant?
• Is there a phrase like "etymologically related" but for food?
• Preventing Javascript in a browser from connecting to servers
• Why are we abbreviating Player's Handbook to PHB?