### 7.3 Modifying Assignment ¶

You can abbreviate the common construct

    lvalue = lvalue + expression

as

    lvalue += expression

This is known as a modifying assignment. For instance,

    i = i + 5;
    i += 5;

shows two statements that are equivalent. The first uses simple assignment; the second uses modifying assignment.

Modifying assignment works with any binary arithmetic operator. For instance, you can subtract something from an lvalue like this,

    lvalue -= expression

or multiply it by a certain amount like this,

    lvalue *= expression

or shift it by a certain amount like this.

    lvalue <<= expression
    lvalue >>= expression

In most cases, this feature adds no power to the language, but it provides substantial convenience. Also, when lvalue contains code that has side effects, the simple assignment performs those side effects twice, while the modifying assignment performs them once. For instance, suppose that the function `foo` has a side effect, perhaps changing static storage. This statement

    x[foo ()] = x[foo ()] + 5;

calls `foo` twice. If `foo` operates on static variables, it could return a different value each time. If `foo ()` will return 1 the first time and 3 the second time, the effect could be to add `x[3]` and 5 and store the result in `x[1]`, or to add `x[1]` and 5 and store the result in `x[3]`. We don’t know which of the two it will do, because C does not specify which call to `foo` is computed first.

Such a statement is not well defined, and shouldn’t be used.

By contrast,

    x[foo ()] += 5;

is well defined: it calls `foo` only once to determine which element of `x` to adjust, and it adjusts that element by adding 5 to it.