34 Assignment and side effects

34.1 Assignment is an expression, not a statement

x = 1 looks like a command, but it is an expression — it yields a value. That value is “the assigned value, converted to the type of the left side”, and so it can be placed inside another expression.

/* The two things assignment does — yielding a value, and changing an object. */
#include <stdio.h>

static int calls;

static int where(void)      /* the computation that picks the place is evaluated too */
{
    calls++;
    printf("  where() called — it picks the place on the left\n");
    return 1;
}

static int what(void)
{
    calls++;
    printf("  what() called — it makes the value on the right\n");
    return 42;
}

int main(void)
{
    int a[3] = {0, 0, 0};

    /* ── (1) assignment is an expression — it yields a value ─────── */
    int x, y;
    x = (y = 7) + 1;                  /* the value of the expression y = 7 is 7 */
    printf("x = (y = 7) + 1  ->  x=%d y=%d\n", x, y);

    int p, q, r;
    p = q = r = 5;                    /* right-associative — r is filled first */
    printf("p = q = r = 5    ->  p=%d q=%d r=%d\n", p, q, r);

    /* ── (2) the left side is evaluated too ──────────────────────── */
    puts("\nrunning a[where()] = what();");
    calls = 0;
    a[where()] = what();
    printf("  both functions were called (%d calls), a[1]=%d\n", calls, a[1]);
    puts("  which of the two is called first is not settled by the standard (unspecified).");

    /* ── (3) compound assignment evaluates the left side once ────── */
    puts("\nrunning a[where()] += 1;");
    calls = 0;
    a[where()] += 1;
    printf("  where() call count: %d (spelled out as a[where()] = a[where()] + 1 it would be 2)\n",
           calls);
    printf("  a[1] = %d\n", a[1]);

    /* ── (4) assignment yields the value *converted* to the left type ─ */
    char c;
    int wide = 321;
    int back = (c = (char)wide);      /* narrowed then widened is not the original */
    printf("\nchar c = (char)321 -> c=%d, value of (c = ...) = %d\n", c, back);

    double d;
    int truncated = (int)(d = 3.9);   /* real to integer truncates toward zero */
    printf("d = 3.9 -> d=%.1f, (int)d = %d\n", d, truncated);

    /* ── (5) side effects get their own statements ──────────────── */
    int i = 0;
    a[i] = 10;
    i++;                              /* never mixed into one expression */
    a[i] = 20;
    printf("\nthe safe shape: a[0]=%d a[1]=%d i=%d\n", a[0], a[1], i);
    return 0;
}

x = (y = 7) + 1  ->  x=8 y=7
p = q = r = 5    ->  p=5 q=5 r=5

running a[where()] = what();
  where() called — it picks the place on the left
  what() called — it makes the value on the right
  both functions were called (2 calls), a[1]=42
  which of the two is called first is not settled by the standard (unspecified).

running a[where()] += 1;
  where() called — it picks the place on the left
  where() call count: 1 (spelled out as a[where()] = a[where()] + 1 it would be 2)
  a[1] = 43

char c = (char)321 -> c=65, value of (c = ...) = 65
d = 3.9 -> d=3.9, (int)d = 3

the safe shape: a[0]=10 a[1]=20 i=1

The first two lines of the output confirm it. In x = (y = 7) + 1 the expression (y = 7) has the value 7, and adding 1 makes x 8. p = q = r = 5 makes all three 5 by the same principle — assignment is right-associative, so it groups as p = (q = (r = 5)) and the value of the inner assignment is handed outward.

One thing should be nailed down. The result of an assignment is not an lvalue. (a = b) = c does not compile. This differs from C++, and it is enough to remember that “assignment yields a value, but not a place”.

34.2 Assignment does two things

Split what E1 = E2 does and it comes to this.

1. It computes a value — E2 is evaluated and converted to the type of E1.
2. It changes an object — that value is written into the place E1 denotes. This is the side effect.

Keeping the two apart is the key to this chapter. The value of the expression can be used at once, but when the side effect actually happens is another question. The standard says only that the side effect must be complete by the next sequence point; when within that span it happens is not settled.

34.3 The left side is evaluated too

This is what beginners miss most often. The left of = is not a “value” but a computation that decides where to write, and that computation runs.

The second block of the example confirms it. Running a[where()] = what(); calls both where() and what(). The left computes “how to find that place”, the right computes “what to write”.

Which of the two is computed first? The standard does not settle it (unspecified). A compiler may compute the right first or the left first. If both computations have side effects, the result can differ with that order — the trap of the next section.

34.4 Compound assignment — the left side is evaluated once

E1 op= E2 is not the same as E1 = E1 op E2. The standard says the only difference is that E1 is evaluated once — and that one line of difference matters in practice.

Look at the third block of the example. In a[where()] += 1;, where() is called once. Spelled out as a[where()] = a[where()] + 1; it would have been called twice, reading one slot and writing another.

There are ten compound assignments — += -= *= /= %= <<= >>= &= ^= |=. Do not forget that the grey zones of each operation come along unchanged: x /= 0 is still outside the contract, and so is x <<= 40 (chapter 28).

34.5 Where the contract ends

Now the famous expressions can be judged. The code below carries no output — printing the result of an expression outside the contract would leave the false knowledge “on this compiler it comes out like this” (chapter 52′s principle).

int i = 0, a[4] = {0};

i = i++;              /* outside the contract — i is modified twice */
a[i] = i++;           /* outside — modified, and read to decide the place */
i = ++i + i++;        /* outside — modified twice */
a[i++] = i;           /* outside — the same reason */
printf("%d %d", i++, i++);  /* outside — no sequence point between arguments */

These, by contrast, are fine.

i = i + 1;            /* the read is to determine the new value */
a[i] = i;             /* one object changed, a[i]; i is only read */
i++, i++;             /* the comma *operator* has a sequence point */
x = (i++) && (i++);   /* so does && */
f(i++);               /* one argument cannot overlap */

a[i] = ++i + i++;        /* outside the contract. Asking "what value" is the wrong question */

int t = i + 1;            /* whatever was intended, settle the value first */
i = t + 1;                /* then change the object */
a[i] = t;

34.6 The conversion hidden in an assignment

An assignment puts the right-hand value in converted to the left-hand type. Chapter 29′s conversion rules apply here quietly, and quietly is the danger.

The fourth block of the example shows it. In c = (char)321 the value is cut to 65, and the value of the assignment expression is that 65 — not what was put in but what went in. That (int)d is 3 after d = 3.9 is the same story (truncation toward zero, chapter 28).

Turning on -Wconversion makes the compiler point at such places. It is a noisy option, hard to switch on across a whole project, but keeping it on for new code is a good habit.

Part VI is over — we laid out the families of types and forged values (chapters 26–29), governed flow (chapters 30–32), and gained the meaning of functions and of assignment (chapters 33–34). The next part is this book’s second mountain, memory: back to chapter 5′s locker corridor, this time walking it in C’s syntax.