Assignment operators
Assignment operators modify the value of the object.
Operator name  Syntax  Overloadable  Prototype examples (for class T)  

Inside class definition  Outside class definition  
simple assignment  a = b

Yes  T& T::operator =(const T2& b);  N/A 
addition assignment  a += b

Yes  T& T::operator +=(const T2& b);  T& operator +=(T& a, const T2& b); 
subtraction assignment  a = b

Yes  T& T::operator =(const T2& b);  T& operator =(T& a, const T2& b); 
multiplication assignment  a *= b

Yes  T& T::operator *=(const T2& b);  T& operator *=(T& a, const T2& b); 
division assignment  a /= b

Yes  T& T::operator /=(const T2& b);  T& operator /=(T& a, const T2& b); 
remainder assignment  a %= b

Yes  T& T::operator %=(const T2& b);  T& operator %=(T& a, const T2& b); 
bitwise AND assignment  a &= b

Yes  T& T::operator &=(const T2& b);  T& operator &=(T& a, const T2& b); 
bitwise OR assignment  a = b

Yes  T& T::operator =(const T2& b);  T& operator =(T& a, const T2& b); 
bitwise XOR assignment  a ^= b

Yes  T& T::operator ^=(const T2& b);  T& operator ^=(T& a, const T2& b); 
bitwise left shift assignment  a <<= b

Yes  T& T::operator <<=(const T2& b);  T& operator <<=(T& a, const T2& b); 
bitwise right shift assignment  a >>= b

Yes  T& T::operator >>=(const T2& b);  T& operator >>=(T& a, const T2& b); 

Contents 
[edit] Explanation
copy assignment operator replaces the contents of the object a
with a copy of the contents of b
(b
is not modified). For class types, this is a special member function, described in copy assignment operator.
move assignment operator replaces the contents of the object 
(since C++11) 
For nonclass types, copy and move assignment are indistinguishable and are referred to as direct assignment.
compound assignment operators replace the contents of the object a
with the result of a binary operation between the previous value of a
and the value of b
.
[edit] Builtin direct assignment
The direct assignment expressions have the form
lhs = rhs

(1)  
lhs = {}

(2)  (since C++11)  
lhs = { rhs }

(3)  (since C++11)  
For the builtin operator, lhs may have any nonconst scalar type and rhs must be implicitly convertible to the type of lhs.
The direct assignment operator expects a modifiable lvalue as its left operand and an rvalue expression or a bracedinitlist (since C++11) as its right operand, and returns an lvalue identifying the left operand after modification. The result is a bitfield if the left operand is a bitfield.
For nonclass types, the right operand is first implicitly converted to the cvunqualified type of the left operand, and then its value is copied into the object identified by left operand.
When the left operand has reference type, the assignment operator modifies the referredto object.
If the left and the right operands identify overlapping objects, the behavior is undefined (unless the overlap is exact and the type is the same).
If the right operand is a bracedinitlist

(since C++11) 
Using an lvalue of volatilequalified nonclass type as left operand of builtin direct assignment operator is deprecated, unless the assignment expression appears in an unevaluated context or is a discardedvalue expression. 
(since C++20) 
In overload resolution against userdefined operators, for every type T
, the following function signatures participate in overload resolution:
T*& operator=(T*&, T*); 

T*volatile & operator=(T*volatile &, T*); 

For every enumeration or pointer to member type T
, optionally volatilequalified, the following function signature participates in overload resolution:
T& operator=(T&, T); 

For every pair A1 and A2, where A1 is an arithmetic type (optionally volatilequalified) and A2 is a promoted arithmetic type, the following function signature participates in overload resolution:
A1& operator=(A1&, A2); 

[edit] Example
#include <iostream> int main() { int n = 0; // not an assignment n = 1; // direct assignment std::cout << n << ' '; n = {}; // zeroinitialization, then assignment std::cout << n << ' '; n = 'a'; // integral promotion, then assignment std::cout << n << ' '; n = {'b'}; // explicit cast, then assignment std::cout << n << ' '; n = 1.0; // floatingpoint conversion, then assignment std::cout << n << ' '; // n = {1.0}; // compiler error (narrowing conversion) int& r = n; // not an assignment r = 2; // assignment through reference std::cout << n << ' '; int* p; p = &n; // direct assignment p = nullptr; // nullpointer conversion, then assignment std::cout << p << ' '; struct { int a; std::string s; } obj; obj = {1, "abc"}; // assignment from a bracedinitlist std::cout << obj.a << ':' << obj.s << '\n'; }
Possible output:
1 0 97 98 1 2 (nil) 1:abc
[edit] Builtin compound assignment
The compound assignment expressions have the form
lhs op rhs  (1)  
lhs op {}

(2)  (since C++11)  
lhs op { rhs }

(3)  (since C++11)  
op    one of *=, /= %=, += =, <<=, >>=, &=, ^=, = 
lhs    for the builtin operator, lhs may have any arithmetic type, except when op is += or =, which also accept pointer types with the same restrictions as + and  
rhs    for the builtin operator, rhs must be implicitly convertible to lhs 
The behavior of every builtin compoundassignment expression E1 op= E2 (where E1 is a modifiable lvalue expression and E2 is an rvalue expression or a bracedinitlist (since C++11)) is exactly the same as the behavior of the expression E1 = E1 op E2, except that the expression E1
is evaluated only once and that it behaves as a single operation with respect to indeterminatelysequenced function calls (e.g. in f(a += b, g()), the += is either not started at all or is completed as seen from inside g()).
In overload resolution against userdefined operators, for every pair A1 and A2, where A1 is an arithmetic type (optionally volatilequalified) and A2 is a promoted arithmetic type, the following function signatures participate in overload resolution:
A1& operator*=(A1&, A2); 

A1& operator/=(A1&, A2); 

A1& operator+=(A1&, A2); 

A1& operator=(A1&, A2); 

For every pair I1 and I2, where I1 is an integral type (optionally volatilequalified) and I2 is a promoted integral type, the following function signatures participate in overload resolution:
I1& operator%=(I1&, I2); 

I1& operator<<=(I1&, I2); 

I1& operator>>=(I1&, I2); 

I1& operator&=(I1&, I2); 

I1& operator^=(I1&, I2); 

I1& operator=(I1&, I2); 

For every optionally cvqualified object type T
, the following function signatures participate in overload resolution:
T*& operator+=(T*&, std::ptrdiff_t); 

T*& operator=(T*&, std::ptrdiff_t); 

T*volatile & operator+=(T*volatile &, std::ptrdiff_t); 

T*volatile & operator=(T*volatile &, std::ptrdiff_t); 

[edit] Example
This section is incomplete Reason: no example 
[edit] Defect reports
The following behaviorchanging defect reports were applied retroactively to previously published C++ standards.
DR  Applied to  Behavior as published  Correct behavior 

CWG 1527  C++11  for assignments to class type objects, the right operand could be an initializer list only when the assignment is defined by a userdefined assignment operator 
removed userdefined assignment constraint 
CWG 1538  C++11  E1 = {E2} was equivalent to E1 = T(E2) ( T is the type of E1 ), this introduced a Cstyle cast

it is equivalent to E1 = T{E2} 
P2327R1  C++20  bitwise compound assignment operators for volatile types were deprecated while being useful for some platforms 
they are not deprecated 
CWG 2654  C++20  compound assignment operators for volatile types were inconsistently deprecated 
none of them is deprecated 
[edit] See also
Common operators  

assignment  increment decrement 
arithmetic  logical  comparison  member access 
other 
a = b 
++a 
+a 
!a 
a == b 
a[...] 
function call 
a(...)  
comma  
a, b  
conditional  
a ? b : c  
Special operators  
static_cast converts one type to another related type 
C documentation for Assignment operators
