A copy 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 without mutating the argument.

[edit]Syntax

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

[edit]Explanation

struct X{    X& operator=(X& other);// copy assignment operator    X operator=(X other);// pass-by-value is allowed//  X operator=(const X other); // Error: incorrect parameter type}; union Y{// copy 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 copy assignment operator is called whenever selected byoverload resolution, e.g. when an object appears on the left side of an assignment expression.

[edit]Implicitly-declared copy assignment operator

If no user-defined copy assignment operators are provided for a class type, the compiler will always declare one as aninlinepublic member of the class. This implicitly-declared copy assignment operator has the formT& T::operator=(const T&) if all of the following is true:

• each direct baseB ofT has a copy assignment operator whose parameters areB orconst B& orconstvolatile B&;
• each non-static data memberM ofT of class type or array of class type has a copy assignment operator whose parameters areM orconst M& orconstvolatile M&.

Otherwise the implicitly-declared copy assignment operator is declared asT& T::operator=(T&).

Due to these rules, the implicitly-declared copy assignment operator cannot bind to avolatile lvalue argument.

A class can have multiple copy assignment operators, e.g. bothT& T::operator=(T&) andT& T::operator=(T).If some user-defined copy assignment operators are present, the user may still force the generation of the implicitly declared copy assignment operator with the keyworddefault.(since C++11)

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

Because the copy assignment operator is always declared for any class, the base class assignment operator is always hidden. If ausing-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 copy assignment operator

If the implicitly-declared copy 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 copy assignment copies the object representation (as bystd::memmove). For non-union class types, the operator performs member-wise copy assignment of the object's direct bases and non-static data members, in their initialization order, using built-in assignment for the scalars, memberwise copy-assignment for arrays, and copy assignment operator for class types (called non-virtually).

[edit]Deleted copy assignment operator

An implicitly-declared or explicitly-defaulted(since C++11) copy assignment operator for classT isundefined(until C++11)defined as deleted(since C++11) 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 copy assignment operator

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

[edit]Trivial copy assignment operator

The copy 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 copy assignment operator selected for every direct base ofT is trivial;
• the copy assignment operator selected for every non-static class type (or array of class type) member ofT is trivial.

A trivial copy assignment operator makes a copy of the object representation as if bystd::memmove. All data types compatible with the C language (POD types) are trivially copy-assignable.

[edit]Eligible copy assignment operator

Triviality of eligible copy 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 copy assignment operator (same applies tomove assignment).

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

[edit]Example

#include <algorithm>#include <iostream>#include <memory>#include <string> struct A{int n;std::string s1;     A()=default;    A(Aconst&)=default; // user-defined copy assignment (copy-and-swap idiom)    A& operator=(A other){std::cout<<"copy assignment of A\n";std::swap(n, other.n);std::swap(s1, other.s1);return*this;}}; struct B: A{std::string s2;// implicitly-defined copy assignment}; struct C{std::unique_ptr<int[]> data;std::size_t size; // user-defined copy assignment (non copy-and-swap idiom)// note: copy-and-swap would always reallocate resources    C& operator=(const C& other){if(this!=&other)// not a self-assignment{if(size!= other.size)// resource cannot be reused{                data.reset(newint[other.size]);                size= other.size;}std::copy(&other.data[0],&other.data[0]+ size,&data[0]);}return*this;}}; int main(){    A a1, a2;std::cout<<"a1 = a2 calls ";    a1= a2;// user-defined copy assignment     B b1, b2;    b2.s1="foo";    b2.s2="bar";std::cout<<"b1 = b2 calls ";    b1= b2;// implicitly-defined copy assignment std::cout<<"b1.s1 = "<< b1.s1<<"; b1.s2 = "<< b1.s2<<'\n';}

a1 = a2 calls copy assignment of Ab1 = b2 calls copy assignment of Ab1.s1 = foo; b1.s2 = bar

[edit]Defect reports

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

[edit]See also

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

• In other languages

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