# Assignment Operators

suggest change

Assigns the value of the right-hand operand to the storage location named by the left-hand operand, and returns the value.

``````int x = 5;      /* Variable x holds the value 5. Returns 5. */
char y = 'c';   /* Variable y holds the value 99. Returns 99
* (as the character 'c' is represented in the ASCII table with 99).
*/
float z = 1.5;  /* variable z holds the value 1.5. Returns 1.5. */
char const* s = "foo"; /* Variable s holds the address of the first character of the string 'foo'. */``````

Several arithmetical operations have a compound assignment operator.

``````a += b  /* equal to: a = a + b */
a -= b  /* equal to: a = a - b */
a *= b  /* equal to: a = a * b */
a /= b  /* equal to: a = a / b */
a %= b  /* equal to: a = a % b */
a &= b  /* equal to: a = a & b */
a |= b  /* equal to: a = a | b */
a ^= b  /* equal to: a = a ^ b */
a <<= b /* equal to: a = a << b */
a >>= b /* equal to: a = a >> b */``````

One important feature of these compound assignments is that the expression on the left hand side (`a`) is only evaluated once. E.g if `p` is a pointer

``*p += 27;``

dereferences `p` only once, whereas the following does so twice.

``*p = *p + 27;``

It should also be noted that the result of an assignment such as `a = b` is what is known as an rvalue. Thus, the assignment actually has a value which can then be assigned to another variable. This allows the chaining of assignments to set multiple variables in a single statement.

This rvalue can be used in the controlling expressions of `if` statements (or loops or `switch` statements) that guard some code on the result of another expression or function call. For example:

``````char *buffer;
if ((buffer = malloc(1024)) != NULL)
{
/* do something with buffer */
free(buffer);
}
else
{
/* report allocation failure */
}``````

Because of this, care must be taken to avoid a common typo which can lead to mysterious bugs.

``````int a = 2;
/* ... */
if (a = 1)
/* Delete all files on my hard drive */``````

This will have disastrous results, as `a = 1` will always evaluate to `1` and thus the controlling expression of the `if` statement will always be true (read more about this common pitfall here). The author almost certainly meant to use the equality operator (`==`) as shown below:

``````int a = 2;
/* ... */
if (a == 1)
/* Delete all files on my hard drive */``````

Operator Associativity

``````int a, b = 1, c = 2;
a = b = c;``````

This assigns `c` to `b`, which returns `b`, which is than assigned to `a`. This happens because all assignment-operators have right associativity, that means the rightmost operation in the expression is evaluated first, and proceeds from right to left.