Assignment operators modify the value of the object.

[edit]Definitions

Copy assignment replaces the contents of the objecta with a copy of the contents ofb (b is not modified). For class types, this is performed in a special member function, described incopy assignment operator.

For non-class types, copy and move assignment are indistinguishable and are referred to asdirect assignment.

Compound assignment replace the contents of the objecta with the result of a binary operation between the previous value ofa and the value ofb.

[edit]Assignment operator syntax

The assignment expressions have the form

1. ↑target-expr must have higherprecedence than an assignment expression.
2. ↑new-value cannot be a comma expression, because itsprecedence is lower.

[edit]Built-in simple assignment operator

For the built-in simple assignment,target-expr must be a modifiable lvalue.

The object referred to bytarget-expr is modified by replacing its value with the result ofnew-value. If the object referred is of an integer typeT, and the result ofnew-value is of the corresponding signed/unsigned integer type, the value of the object is replaced with the value of typeT with the same value representation of the result ofnew-value.

The result of a built-in simple assignment is an lvalue of the type oftarget-expr, referring totarget-expr. Iftarget-expr is abit-field, the result is also a bit-field.

[edit]Assignment from an expression

Ifnew-value is an expression, it isimplicitly converted tothe cv-unqualified type oftarget-expr. Whentarget-expr is a bit-field that cannot represent the value of the expression, the resulting value of the bit-field is implementation-defined.

Iftarget-expr andnew-value identify overlapping objects, the behavior is undefined (unless the overlap is exact and the type is the same).

#include <complex> std::complex<double> z;z={1,2};// meaning z.operator=({1, 2})z+={1,2};// meaning z.operator+=({1, 2}) int a, b;a= b={1};// meaning a = b = 1;a={1}= b;// syntax error

Inoverload resolution against user-defined operators, for every typeT, the following function signatures participate in overload resolution:

For every enumeration or pointer to member typeT, optionally volatile-qualified, the following function signature participates in overload resolution:

For every pairA1 andA2, whereA1 is an arithmetic type (optionally volatile-qualified) andA2 is a promoted arithmetic type, the following function signature participates in overload resolution:

[edit]Built-in compound assignment operator

The behavior of every built-in compound-assignment expressiontarget-expr op = new-value is exactly the same as the behavior of the expressiontarget-expr = target-expr op new-value, except thattarget-expr is evaluated only once.

The requirements ontarget-expr andnew-value of built-in simple assignment operators also apply. Furthermore:

• For+= and-=, the type oftarget-expr must be anarithmetic type or a pointer to a (possibly cv-qualified) completely-definedobject type.
• For all other compound assignment operators, the type oftarget-expr must be an arithmetic type.

Inoverload resolution against user-defined operators, for every pairA1 andA2, whereA1 is an arithmetic type (optionally volatile-qualified) andA2 is a promoted arithmetic type, the following function signatures participate in overload resolution:

For every pairI1 andI2, whereI1 is an integral type (optionally volatile-qualified) andI2 is a promoted integral type, the following function signatures participate in overload resolution:

For every optionally cv-qualified object typeT, the following function signatures participate in overload resolution:

[edit]Example

#include <iostream> int main(){int n=0;// not an assignment     n=1;// direct assignmentstd::cout<< n<<' ';     n={};// zero-initialization, then assignmentstd::cout<< n<<' ';     n='a';// integral promotion, then assignmentstd::cout<< n<<' ';     n={'b'};// explicit cast, then assignmentstd::cout<< n<<' ';     n=1.0;// floating-point conversion, then assignmentstd::cout<< n<<' '; //  n = {1.0};        // compiler error (narrowing conversion) int& r= n;// not an assignment    r=2;// assignment through referencestd::cout<< n<<' '; int* p;    p=&n;// direct assignment    p= nullptr;// null-pointer conversion, then assignmentstd::cout<< p<<' '; struct{int a;std::string s;} obj;    obj={1,"abc"};// assignment from a braced-init-liststd::cout<< obj.a<<':'<< obj.s<<'\n';}

1 0 97 98 1 2 (nil) 1:abc

[edit]Defect reports

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

[edit]See also

Operator precedence

Operator overloading

• In other languages

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