A move assignment operator is a non-templatenon-static member function with the nameoperator= that can be called with an argument of the same class type and copies the content of the argument, possibly mutating the argument.

[edit]Syntax

For the formal move assignment operator syntax, seefunction declaration. The syntax list below only demonstrates a subset of all valid move assignment operator syntaxes.

[edit]Explanation

struct X{    X& operator=(X&& other);// move assignment operator//  X operator=(const X other); // Error: incorrect parameter type}; union Y{// move assignment operators can have syntaxes not listed above,// as long as they follow the general function declaration syntax// and do not viloate the restrictions listed aboveauto operator=(Y&& other)-> Y&;// OK: trailing return type    Y& operator=(this Y&& self, Y& other);// OK: explicit object parameter//  Y& operator=(Y&&, int num = 1);        // Error: has other non-object parameters};

The move assignment operator is called whenever it is selected byoverload 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 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 assignment doesn’t change the lifetime of the argument, the destructor will typically be called on the argument at a later point. For example, move-assigning from astd::string or from astd::vector may result in the argument being left empty. 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.

[edit]Implicitly-declared move assignment operator

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

• there are no user-declaredcopy constructors;
• there are no user-declaredmove constructors;
• there are no user-declaredcopy assignment operators;
• there is no user-declareddestructor,

then the compiler will declare a move assignment operator as aninlinepublic member of its class with the signatureT& T::operator=(T&&).

A class can have multiple move assignment operators, e.g. bothT& T::operator=(const T&&) andT& 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 keyworddefault.

The implicitly-declared move assignment operator has an exception specification as described indynamic exception specification(until C++17)noexcept 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.

[edit]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 ifodr-used orneeded for constant evaluation(since C++14).

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

For non-union class types, 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).

As with copy assignment, 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:

struct V{    V& operator=(V&& other){// this may be called once or twice// if called twice, 'other' is the just-moved-from V subobjectreturn*this;}}; struct A:virtual V{};// operator= calls V::operator=struct B:virtual V{};// operator= calls V::operator=struct C: B, A{};// operator= calls B::operator=, then A::operator=// but they may only call V::operator= once int main(){    C c1, c2;    c2= std::move(c1);}

[edit]Deleted move assignment operator

The implicitly-declared or defaulted move assignment operator for classT is defined as deleted if any of the following conditions is satisfied:

• T has a non-static data member of a const-qualified non-class type (or possibly multi-dimensional array thereof).
• T has a non-static data member of a reference type.
• T has apotentially constructed subobject of class typeM (or possibly multi-dimensional array thereof) such that the overload resolution as applied to findM's move assignment operator

• does not result in a usable candidate, or
• in the case of the subobject being avariant member, selects a non-trivial function.

A deleted implicitly-declared move assignment operator is ignored byoverload resolution.

[edit]Trivial move assignment operator

The move assignment operator for classT 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 ofT is trivial;
• the move assignment operator selected for every non-static class type (or array of class type) member ofT 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 bystd::memmove. All data types compatible with the C language are trivially move-assignable.

[edit]Eligible move assignment operator

Triviality of eligible move assignment operators determines whether the class is atrivially copyable type.

[edit]Notes

If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is anrvalue (either aprvalue such as a nameless temporary or anxvalue such as the result ofstd::move), and selects the copy assignment if the argument is anlvalue (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 tocopy assignment).

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

[edit]Example

#include <iostream>#include <string>#include <utility> struct A{std::string s;     A(): s("test"){}     A(const A& o): s(o.s){std::cout<<"move failed!\n";}     A(A&& o): s(std::move(o.s)){}     A& operator=(const A& other){         s= other.s;std::cout<<"copy assigned\n";return*this;}     A& operator=(A&& other){         s= std::move(other.s);std::cout<<"move assigned\n";return*this;}}; A f(A a){return a;} struct B: A{std::string s2;int n;// implicit move assignment operator B& B::operator=(B&&)// calls A's move assignment operator// calls s2's move assignment operator// and makes a bitwise copy of n}; struct C: B{    ~C(){}// destructor prevents implicit move assignment}; struct D: B{    D(){}    ~D(){}// destructor would prevent implicit move assignment    D& operator=(D&&)=default;// force a move assignment anyway}; int main(){    A a1, a2;std::cout<<"Trying to move-assign A from rvalue temporary\n";    a1= f(A());// move-assignment from rvalue temporarystd::cout<<"Trying to move-assign A from xvalue\n";    a2= std::move(a1);// move-assignment from xvalue std::cout<<"\nTrying to move-assign B\n";    B b1, b2;std::cout<<"Before move, b1.s =\""<< b1.s<<"\"\n";    b2= std::move(b1);// calls implicit move assignmentstd::cout<<"After move, b1.s =\""<< b1.s<<"\"\n"; std::cout<<"\nTrying to move-assign C\n";    C c1, c2;    c2= std::move(c1);// calls the copy assignment operator std::cout<<"\nTrying to move-assign D\n";    D d1, d2;    d2= std::move(d1);}

Trying to move-assign A from rvalue temporarymove assignedTrying to move-assign A from xvaluemove assigned Trying to move-assign BBefore move, b1.s = "test"move assignedAfter move, b1.s = "" Trying to move-assign Ccopy assigned Trying to move-assign Dmove assigned

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]See also

• constructor
• converting constructor
• copy assignment
• copy constructor
• default constructor
• destructor
• initialization
  • aggregate initialization
  • constant initialization
  • copy initialization
  • default initialization
  • direct initialization
  • list initialization
  • reference initialization
  • value initialization
  • zero initialization
• move constructor

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文