A move constructor is a
which can be called with an argument of the same class type and copies the content of the argument, possibly mutating the argument.
Syntax
class-name(parameter-list);(1) class-name(parameter-list)function-body(2) class-name(single-parameter-list) = default;(3) class-name(parameter-list) = delete;(4) class-name::class-name(parameter-list)function-body(5) class-name::class-name(single-parameter-list) = default;(6) class-name- the class whose move constructor is being declared parameter-list- a non-empty
satisfying all following conditions: given the class type as T, the first parameter is of type T&&, constT&&, volatileT&& or constvolatileT&&, and
either there are no other parameters, or all other parameters have
single-parameter-list- a
of only one parameter, which is of type T&&, constT&&, volatileT&& or constvolatileT&& and does not have a default argument function-body- the
of the move constructor Explanation
1) Declaration of a move constructor inside of class definition.
2-4) Definition of a move constructor inside of class definition.
3) The move constructor is explicitly-defaulted.
4) The move constructor is deleted.
5,6) Definition of a move constructor outside of class definition (the class must contain a declaration (1)).
6) The move constructor is explicitly-defaulted.
structX{X(X&&other);// move constructor// X(X other); // Error: incorrect parameter type};unionY{Y(Y&&other,intnum=1);// move constructor with multiple parameters// Y(Y&& other, int num); // Error: `num` has no default argument};The move constructor is typically called when an object is
(by
or
) from
(xvalue or prvalue)(until C++17)xvalue(since C++17) of the same type, including
initialization: Ta=std::move(b); or Ta(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 voidf(Tt);
function return: returna; inside a function such as Tf(), 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
.
Move constructors typically transfer the resources held by the argument (e.g. pointers to dynamically-allocated objects, file descriptors, TCP sockets, thread handles, etc.) rather than make copies of them, and leave the argument in some valid but otherwise indeterminate state. Since move constructor doesn’t change the lifetime of the argument, the destructor will typically be called on the argument at a later point. For example, moving from a
or from a
may result in the argument being left empty. For some types, such as
, the moved-from state is fully specified.
Implicitly-declared move constructor
If no user-defined move constructors are provided for a class type, and all of the following is true:
there are no user-declared
;
there are no user-declared
;
there are no user-declared
;
there is no user-declared
.
Then the compiler will declare a move constructor as a non-
inlinepublic member of its class with the signature T::T(T&&).
A class can have multiple move constructors, e.g. both T::T(constT&&) 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)
(since C++17).
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
or
needed for constant evaluation
. For union types, the implicitly-defined move constructor copies the object representation (as by
). For non-union class types, the move constructor performs full member-wise move of the object's direct base subobjects and member subobjects, in their initialization order, using direct initialization with an
argument. For each non-static data member of a reference type, the move constructor binds the reference to the same object or function to which the source reference is bound.
If this satisfies the requirements of a
(until C++23)
(since C++23), the generated move constructor is constexpr.
Deleted move constructor
The implicitly-declared or explicitly-defaulted move constructor for class T is defined as deleted if T has a
potentially constructed subobject
of class type M (or possibly multi-dimensional array thereof) such that
M has a destructor that is deleted or inaccessible from the copy constructor, or
the overload resolution as applied to find M's move constructor
does not result in a usable candidate, or
in the case of the subobject being a
, selects a non-trivial function.
Such a constructor is ignored by
(otherwise it would prevent copy-initialization from rvalue).
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
. All data types compatible with the C language are trivially movable.
Eligible move constructor
A move constructor is eligible if it is not deleted.
(until C++20)A move constructor is eligible if all following conditions are satisfied:
It is not deleted.
Its
(if any) are satisfied.
No move constructor whose associated constraints are satisfied is
.
(since C++20)Triviality of eligible move constructors determines whether the class is an
, and whether the class is a
.
Notes
To make the
possible, user-defined move constructors should not throw exceptions. For example,
relies on
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
of the same type (an
such as the result of std::move or a
such as a nameless temporary(until C++17)), and selects the copy constructor if the argument is an
(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.
Example
Run this code
#include<iomanip>#include<iostream>#include<string>#include<utility>structA{std::strings;intk;A():s("test"),k(-1){}A(constA&o):s(o.s),k(o.k){std::cout<<"move failed!\n";}A(A&&o)noexcept:s(std::move(o.s)),// explicit move of a member of class typek(std::exchange(o.k,0))// explicit move of a member of non-class type{}};Af(Aa){returna;}structB:A{std::strings2;intn;// implicit move constructor B::(B&&)// calls A's move constructor// calls s2's move constructor// and makes a bitwise copy of n};structC:B{~C(){}// destructor prevents implicit move constructor C::(C&&)};structD:B{D(){}~D(){}// destructor would prevent implicit move constructor D::(D&&)D(D&&)=default;// forces a move constructor anyway};intmain(){std::cout<<"Trying to move A\n";Aa1=f(A());// return by value move-constructs the target// from the function parameterstd::cout<<"Before move, a1.s = "<<std::quoted(a1.s)<<" a1.k = "<<a1.k<<'\n';Aa2=std::move(a1);// move-constructs from xvaluestd::cout<<"After move, a1.s = "<<std::quoted(a1.s)<<" a1.k = "<<a1.k<<'\n';std::cout<<"\nTrying to move B\n";Bb1;std::cout<<"Before move, b1.s = "<<std::quoted(b1.s)<<"\n";Bb2=std::move(b1);// calls implicit move constructorstd::cout<<"After move, b1.s = "<<std::quoted(b1.s)<<"\n";std::cout<<"\nTrying to move C\n";Cc1;Cc2=std::move(c1);// calls copy constructorstd::cout<<"\nTrying to move D\n";Dd1;Dd2=std::move(d1);}Output:
Trying to move A Before move, a1.s = "test" a1.k = -1 After move, a1.s = "" a1.k = 0 Trying to move B Before move, b1.s = "test" After move, b1.s = "" Trying to move C move failed! Trying to move D Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR Applied to Behavior as published Correct behavior
C++11 the conditions where defaulted move constructors are
defined as deleted did not consider multi-dimensional array types consider these types
C++11 a defaulted move constructor that would call
a non-trivial copy constructor was defined as
deleted; a defaulted move constructor that is
deleted still participated in overload resolution allows call to such copy
constructor; made ignored
in overload resolution
C++11 a defaulted move constructor of a class with a non-static data
member of rvalue reference type was defined as deleted not deleted in this case
C++11 a volatile subobject made a defaulted
move constructor non-trivial (
) triviality not affected
C++20 a move constructor was not eligible if there is
another move constructor which is more constrained
but does not satisfy its associated constraints it can be eligible in this case See also