Next: , Previous: , Up: Assignment Expressions   [Contents][Index]

### 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,

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

calls `foo` twice, and it could return different values each time. If `foo ()` returns 1 the first time and 3 the second time, then the effect could be to add `x` and 5 and store the result in `x`, or to add `x` and 5 and store the result in `x`. 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.

Next: , Previous: , Up: Assignment Expressions   [Contents][Index]