35 Assignment and side effects

35.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”.

35.2 Assignment does three things#

Split E1 = E2 in the standard’s own vocabulary and it is three evaluations, not two — because the left side is computed as well.

1. The value computation of the left operand — E1 is evaluated to settle which object is to be written. The standard is explicit that the value computation of an lvalue expression includes determining the identity of the designated object (§5.1.2.3).
2. The value computation of the right operand — E2 is evaluated and its value converted to the type of the assignment expression (§6.5.17.2p2).¹
3. The side effect of storing — that value is written into the place settled above.

They must be kept as three because the ordering between them differs by pair.

“Unsequenced” does not mean “one of them goes first and we do not know which”. It is stronger: the standard says A may be neither before nor after B (§5.1.2.4p3). So the two computations may interleave and still conform. The term for “we only do not know which goes first” is a different one — indeterminately sequenced — and the body of a function call stands in that relation (§6.5.3.3p8). So the calls f() and g() do not interleave, while two computations that call nothing may.

Put §6.5.1p2 on top and the contract is complete.

35.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. A compiler may compute the right first or the left first. Here both computations are function calls, so they at least do not interleave — the indeterminate sequencing of the previous section. Only the order is unknown; one finishes before the other starts. Two computations that are not calls have no such protection (they are simply unsequenced). Either way, if both have side effects the result can differ with the order — the trap of the next section.

35.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 29).

35.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 54′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;

35.6 The conversion hidden in an assignment#

An assignment puts the right-hand value in converted to the left-hand type. Chapter 30′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 29).

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 27–30), governed flow (chapters 31–33), and gained the meaning of functions and of assignment (chapters 34–35). The next part is this book’s second mountain, memory: back to chapter 3′s locker corridor, this time walking it in C’s syntax.