Assignment operators

Assignment and compound assignment operators are binary operators that modify the variable to their left using the value to their right.

Simple assignment

The simple assignment operator expressions have the form

where

Assignment performs implicit conversion from the value of rhs to the type of rhs and then replaces the value in the object designated by lhs with the converted value of rhs.

Assignment also returns the same value as what was stored in lhs (so that expressions such as a = b = c are possible). The value category of the assignment operator is non-lvalue (so that expressions such as (a=b)=c are invalid).

rhs and lhs must satisfy one of the following:

• both lhs and rhs have compatible struct or union type, or..
• rhs must be implicitly convertible to lhs, which implies

• both lhs and rhs have arithmetic types, in which case lhs may be volatile-qualified or atomic
• both lhs and rhs have pointer to compatible (ignoring qualifiers) types, or one of the pointers is a pointer to void, and the conversion would not add qualifiers to the pointed-to type. lhs may be volatile or restrict-qualified or atomic.
• lhs is a pointer (possibly qualified or atomic) and rhs is a null pointer constant such as NULL
• lhs has type _Bool (possibly qualified or atomic) and rhs is a pointer

Notes

If rhs and lhs overlap in memory (e.g. they are members of the same union), the behavior is undefined unless the overlap is exact and the types are compatible.

Although arrays are not assignable, an array wrapped in a struct is assignable to another object of the same (or compatible) struct type.

The side effect of updating lhs is sequenced after the value computations, but not the side effects of lhs and rhs themselves and the evaluations of the operands are, as usual, unsequenced relative to each other (so the expressions such as i=++i; are undefined)

Assignment strips extra range and precision from floating-point expressions (see FLT_EVAL_METHOD).

In C++, assignment operators are lvalue expressions, not so in C

#include <stdio.h>
 
int main(void)
{
    const char **cpp;
    char *p;
    const char c = 'A';
 
//  cpp = &p;  // Error: char** is not convertible to const char**
    *cpp = &c; // OK, char* is convertible to const char*
    *p = 0;    // OK, null pointer constant is convertible to any pointer
 
    int arr1[2] = {1,2}, arr2[2] = {3, 4};
//  arr1 = arr2; // Error: cannot assign to an array
 
    struct s { 
         int arr[2]; // an array wrapped in a struct
    } sam1 = {5, 6}, sam2 = {7, 8};
    sam1 = sam2; // OK: can assign arrays wrapped in structs
 
    printf("%d %d \n",sam1.arr[0],sam1.arr[1]);
}

7 8

Compound assignment

The compound assignment operator expressions have the form

where

The expression lhs @= rhs is exactly the same as lhs = lhs @ ( rhs ), except that lhs is evaluated only once.

T1* addr = &lhs;
T2 val = rhs;
T1 old = *addr;
T1 new;
do { new = old @ val } while (!atomic_compare_exchange_strong(addr, &old, new);

References