52 Expressions and operators

52.1 Expressions in mathematics, expressions in C#

“Expression” and “operator” are words we first learned in mathematics. C borrowed them, but the meaning shifted quite a lot. Make the difference clear first, and the rest of this chapter reads as its consequences.

In mathematics an expression is numbers, variables and operation symbols put together by the rules, and it denotes one value. 2 + 3 × 4 denotes 14. An operator is a function that takes operands and gives one result — addition is a function from two reals to one real. And “evaluating” an expression changes nothing in the world. Evaluate x + 1 a hundred times and x is still x; whenever and in whatever order you evaluate it, the value is the same. That is why, in mathematics, x = x + 1 is a false equation.

In C an expression has the same shape, but four things differ.

★ Where the second and fourth rows meet is the trickiest spot in C expressions. If an expression changes things and the moment of change is not fully fixed, what does code that changes the same object twice in one expression mean? This chapter ends with the standard’s answer to that question.

52.2 The rigorous definition — expression, operator, operand#

The standard defines an expression like this.

“ An expression is a sequence of operators and operands that specifies computation of a value, or that designates an object or a function, or that generates side effects, or that performs a combination thereof. The value computations of the operands of an operator are sequenced before the value computation of the result of the operator.¹ ”

The branches joined by “or” are the first row of the table above. With an example each:

Note the definition’s second sentence as well. In (a + b) * c, the product’s value is settled only after the values of a + b and c — obvious, but it is the only order the standard guarantees between an operator and its operands. It does not say whether a + b or c is computed first.

Operator and operand are defined where the standard classifies tokens.

“ A punctuator is a symbol that has independent syntactic and semantic significance. Depending on context, it may specify an operation to be performed (which in turn may yield a value or a function designator, produce a side effect, or some combination thereof) in which case it is known as an operator (other forms of operator also exist in some contexts). An operand is an entity on which an operator acts.² ”

Three practical facts follow.

• The same symbol is an operator in one context and not in another. The comma in f(a, b) is a separator between arguments; the comma in (a, b) is the comma operator. The * of int *p is part of a declaration; the * of *p = 0 is the indirection operator. The = of int x = 1; marks an initialisation, not the assignment operator. The same look does not bring the same rules — in the sequence point table later, exactly this distinction makes the difference.
• There are “other forms of operator”. Operators made of words, like sizeof and alignof, and operators that come in pairs, like ( ) (function call), [ ] (subscript) and ? : (conditional).
• Operators are sorted by how many operands they take. One makes it unary (-x, !b, *p, &x, sizeof x), two binary (a + b, x = y), three ternary. C has exactly one ternary operator, ? :.

Expressions build up recursively. The smallest expressions — what the standard calls primary expressions: identifiers, constants, string literals and parenthesised expressions — are the leaves, and operators take expressions as operands to make bigger ones. a + b * c is an addition whose operand is the expression b * c. So an expression is tree-shaped, and what fixes the tree’s shape is precedence and associativity (in the standard’s words, “the grouping of operators and operands is indicated by the syntax”, §6.5.1p3). The outermost expression that is part of no other — all of x = a + b in the statement x = a + b; — is a full expression (§6.8.1p4). That word comes back with sequence points.

52.3 Side effects — what happens besides the value#

The word that decisively separates mathematical expressions from C expressions is side effect. The standard’s definition:

“ A volatile access to an object, modifying an object, modifying a file, or calling a function that does any of those operations are all side effects, which are changes in the state of the execution environment. Evaluation of an expression in general includes both value computations and initiation of side effects.³ ”

The list has four entries. In the shapes this book has already met:

Of C’s operators, only three cause side effects by themselves — assignment (= and compound assignment), increment/decrement (++, --) and the function call. There is one exception that is not an operator. As the table’s third row says, reading the value of a volatile object is itself a side effect, so an expression that merely reads *reg through volatile int *reg carries a side effect too. The rest (+, *, <, &&, ?: …) only compute values, like the operators of mathematics. But if there is a side effect inside their operands, the whole expression carries it.

#include <stdio.h>

static int calls;

static bool hit(bool v)          /* changes calls: a side effect */
{
    calls++;
    return v;
}

int main(void)
{
    puts("[1] an expression has a value, and may also do something");
    int x = 0;
    int v = (x = 5) + 1;        /* the assignment has value 5, and x changes */
    printf("v = %d, x = %d\n", v, x);

    int i = 3;
    int post = i++;             /* value 3, effect: i becomes 4 */
    int pre  = ++i;             /* value 5, effect: i becomes 5 */
    printf("post = %d, pre = %d, i = %d\n", post, pre, i);

    puts("\n[2] && skips its right side --- and the side effects in it");
    calls = 0;
    bool r = hit(false) && hit(true);
    printf("result %d, hit() called %d time(s)\n", r, calls);
    calls = 0;
    r = hit(true) || hit(false);
    printf("result %d, hit() called %d time(s)\n", r, calls);

    puts("\n[3] the comma operator: left, then right; value of the right");
    int c = (calls = 0, calls + 10);
    printf("c = %d\n", c);

    puts("\n[4] one change per object between sequence points");
    int k = 0;
    k++, k++;                   /* comma operator: sequence point */
    k++;                        /* each full expression ends one */
    k++;
    printf("k = %d\n", k);
    return 0;
}

[1] an expression has a value, and may also do something
v = 6, x = 5
post = 3, pre = 5, i = 5

[2] && skips its right side --- and the side effects in it
result 0, hit() called 1 time(s)
result 1, hit() called 1 time(s)

[3] the comma operator: left, then right; value of the right
c = 10

[4] one change per object between sequence points
k = 4

The first group separates “value” from “effect”. In (x = 5) + 1 the assignment’s value is 5, so v became 6, and separately the effect of setting x to 5 happened. The value of i++ is the 3 from before the change; the value of ++i is the 5 from after. The second group shows that when && or || does not evaluate its right side, the side effects inside it (here a function call that increments calls) do not happen. The comma operator in the third group evaluates the left and throws it away, giving the right’s value.

Look at the definition’s last words, “initiation of side effects”. Evaluation only starts a side effect; when it finishes is decided by other rules. The value 5 of x = 5 may be settled now, while the moment 5 is actually written into x’s memory can be somewhere later. That gap is the starting point of “Evaluation order and sequence points”, later in this chapter.

52.4 The four things an expression carries#

Every expression in C carries four things at once. Keeping them apart is most of what this chapter teaches.

Value category sounds like jargon, but you have been using it all along. What may appear on the left of an assignment is an lvalue (chapter 35), and what you may apply & to is an lvalue (chapter 36). An array name is an lvalue that nonetheless cannot be assigned to — a special case (chapter 39).

The notations for writing a constant — bases, prefixes, suffixes, escapes, string literals — are gathered in chapter 21, “Every way of writing a constant”, and the rule that settles an integer constant’s type is in chapter 28. This chapter deals with the operators that join those leaves.

52.5 Precedence and associativity#

The table below lists the operator groups from the highest precedence down: the higher the row, the more strongly its operators bind. Associativity decides which side groups first when operators of the same strength stand side by side — a - b - c is (a - b) - c because it is left-associative, and a = b = 0 is a = (b = 0) because assignment is right-associative.

52.6 Places where precedence trips people up#

A table is only a table. Running the same thing makes it stick far faster — the demo below prints the parenthesised and unparenthesised forms side by side.

// Precedence, associativity and short circuiting, seen with the eyes.
// Instead of memorising a table, print the parenthesised and unparenthesised forms side by side.
#include <stdio.h>

static int calls = 0;

static int loud(int value)          // leaves a trace every time it is called
{
    calls += 1;
    return value;
}

int main(void)
{
    int x = 6;

    puts("1. precedence --- what binds tighter");
    printf("  2 + 3 * 4      = %d   (same as 2 + (3 * 4))\n", 2 + 3 * 4);
    printf("  (2 + 3) * 4    = %d\n", (2 + 3) * 4);
    printf("  1 << 2 + 3     = %d   (same as 1 << (2 + 3): + binds tighter than <<)\n",
           1 << (2 + 3));

    puts("2. the classic trap --- == binds tighter than &");
    printf("  x & 1 == 0     is read as x & (1 == 0) = %d\n", x & (1 == 0));
    printf("  what was meant: (x & 1) == 0         = %d\n", (x & 1) == 0);

    puts("3. associativity --- which side groups first");
    printf("  10 - 4 - 3     = %d   (left to right: (10 - 4) - 3)\n", 10 - 4 - 3);
    int a, b;
    a = b = 5;                      // assignment groups from the right
    printf("  a = b = 5      gives a=%d b=%d   (right to left)\n", a, b);

    puts("4. comparison does not chain the way mathematics does");
    printf("  1 < 2 < 3      = %d   ((1 < 2) is 1, and 1 < 3 is true)\n", (1 < 2) < 3);
    printf("  3 > 2 > 1      = %d   ((3 > 2) is 1, and 1 > 1 is false)\n", (3 > 2) > 1);

    puts("5. short circuit --- the right side may never run");
    calls = 0;
    if (0 && loud(1))
        puts("  not reached");
    printf("  after 0 && loud(1): loud() was called %d time(s)\n", calls);
    calls = 0;
    if (1 || loud(1))
        (void)0;
    printf("  after 1 || loud(1): loud() was called %d time(s)\n", calls);
    return 0;
}

1. precedence --- what binds tighter
  2 + 3 * 4      = 14   (same as 2 + (3 * 4))
  (2 + 3) * 4    = 20
  1 << 2 + 3     = 32   (same as 1 << (2 + 3): + binds tighter than <<)
2. the classic trap --- == binds tighter than &
  x & 1 == 0     is read as x & (1 == 0) = 0
  what was meant: (x & 1) == 0         = 1
3. associativity --- which side groups first
  10 - 4 - 3     = 3   (left to right: (10 - 4) - 3)
  a = b = 5      gives a=5 b=5   (right to left)
4. comparison does not chain the way mathematics does
  1 < 2 < 3      = 1   ((1 < 2) is 1, and 1 < 3 is true)
  3 > 2 > 1      = 0   ((3 > 2) is 1, and 1 > 1 is false)
5. short circuit --- the right side may never run
  after 0 && loud(1): loud() was called 0 time(s)
  after 1 || loud(1): loud() was called 0 time(s)

Look closely at the fourth group. 1 < 2 < 3 is true while 3 > 2 > 1 is false. Read with the habits of mathematics both should be true, but C groups two at a time from the left and turns each comparison’s result into a number, 0 or 1, which it then hands to the next comparison. The fifth group is the short circuit of && and || — when the left side settles the answer, the right side is not evaluated at all, so anything that “must happen” placed on the right quietly disappears (chapter 33).

The first row of the table before the demo, a & b == c, is counted among C’s famous design scars — that the bitwise operators bind more weakly than the comparisons is a trace of early C, before it had && and ||. So parentheses are effectively mandatory around a bit test. The standard itself notes in a footnote that a<b<c does not read as it does in mathematics.

52.7 Prefix and postfix — the same job, a different value#

++ and -- can go before or after the operand. Knowing exactly how the prefix and postfix forms differ is a good part of the power to read C expressions, so they are gathered here.

52.7.1 The contract the standard sets#

The only difference is the value the expression yields. What happens to the object is identical. So in a place where the value is not used — the third slot of a for, a statement that is just i++; — the two mean exactly the same thing.

52.7.2 When the value is settled, and when memory changes#

This is the heart of the section. In x++ the event of settling the value and the event of changing memory are two different events, and the standard fixes only their order.

How to read that matters. The standard nails down the relative order, not the moment.

i = i++ + 1;                 /* outside the contract — undefined behaviour */
a[i] = i++;                  /* outside the contract */
printf("%d %d\n", i++, i++); /* outside the contract */

52.7.3 The truth of “prefix is faster”#

What about today’s compilers? Measuring with gcc 14 and clang 19 on this machine (x86-64) settles it.

Two things to read out. First, for C scalars there is no speed difference. Where the value is unused the compiler emits the same code. Second, where the value is used and the code differs, that is not “postfix is slower” but “the two compute different things” — one needs the old value, the other the new.

52.7.4 Two things change in C++#

52.8 Operator by operator#

Now the operators’ contracts, one operator group of the precedence table at a time. Every table has the same columns.

• Operands — what the standard requires. Violate it and the compiler must diagnose it (a constraint violation).
• Result — the type of the value, and whether it is an lvalue.
• Grey zone — in the three words of chapter 56. UB is undefined behaviour, unspecified means one of several possibilities with no rule saying which, and implementation-defined means the implementation chooses and documents it.
• In detail — the chapter that tells the story.

52.9 Postfix operators#

52.10 Unary operators#

52.11 Arithmetic operators#

Integer division truncates toward zero (settled since C99). So, as long as the quotient is representable, (a/b)*b + a%b == a holds.

52.12 Shift operators#

52.13 Relational and equality operators#

The two families have different contracts. Equality may be tested between different objects, while ordering only means something within one array. An object that is not an array is treated as an array of length one. For reals, +0.0 and -0.0 compare equal (chapter 54).

52.14 Bitwise and logical operators#

52.15 Conditional, assignment, comma#

52.16 Evaluation order and sequence points#

We have seen two things. Evaluating an expression only starts a side effect (the “Side effects” section above), and precedence is a rule about grouping, not about the order in time (chapters 14 and 34). So when can we trust that a side effect has finished? This section is the answer — what this book planted as a seed in chapter 21 and handled piece by piece in chapter 34 and chapter 35 is closed properly here.

52.16.1 Three relations — before, unsequenced, one-or-the-other#

Since C11 the standard writes the order among evaluations as relations.

“ Sequenced before is an asymmetric, transitive, pair-wise relation between evaluations executed by a single thread, which induces a partial order among those evaluations. Given any two evaluations A and B, if A is sequenced before B, then the execution of A shall precede the execution of B. … If A is not sequenced before or after B, then A and B are unsequenced. Evaluations A and B are indeterminately sequenced when A is sequenced either before or after B, but it is unspecified which.⁴ ”

The key point is that “unsequenced” is the weakest of the three. It does not mean “one of them comes first and we do not know which” — a machine that does half of A, then B, then the rest of A still conforms. Only function bodies are, exceptionally, not split up. They stand indeterminately sequenced with the caller’s other evaluations (§6.5.3.3p8), so the bodies of two functions do not interleave.

52.16.2 Sequence points — “everything up to here is done”#

A sequence point is a spot that sets up those relations all at once. In the standard’s words, a sequence point between the evaluations of A and B means every value computation and side effect associated with A is sequenced before every value computation and side effect associated with B (§5.1.2.4p3). Past that spot, the earlier side effects have all finished.

These are all the sequence points the standard lists (Annex C).

There are also orderings that are not sequence points. “Operand value computations → the result’s value computation”, read above (§6.5.1p1); in assignment, “value computations of both sides → the store” (§6.5.17.1p3, chapter 35); in postfix increment, “value computation of the result → the store” (§6.5.3.5p2). These fix the order of two particular events only; they do not promise that any other side effect has finished in between.

52.16.3 The rule that leaves the contract — two unsequenced accesses to one object#

Now the central sentence of the rule.

“ If a side effect on a scalar object is unsequenced relative to either a different side effect on the same scalar object or a value computation using the value of the same scalar object, the behavior is undefined.⁵ ”

Two shapes leave the contract: changing the same object twice without an order, and changing it while reading its value without an order. Judged with the relation table above:

The difference between unspecified and UB becomes visible. This book ran the same code with both compilers.

static int f(void) { puts("f"); return 1; }
static int g(void) { puts("g"); return 2; }
printf("args %d %d\n", f(), g());     /* unspecified */
printf("%d %d\n", i, i++);            /* UB, i is 3 */

The first row is unspecified, so both are right. Whatever the order, each function was called exactly once. The second row is UB, so neither is “the right answer” — the same source printed different numbers with different compilers, and with another version or optimisation level it could differ again.

The tools catch the common shapes. This is what the two compilers said about the code above.

gcc:   warning: operation on ‘i’ may be undefined [-Wsequence-point]
clang: warning: unsequenced modification and access to 'i' [-Wunsequenced]
clang: warning: unsequenced modification and access to 'i' [-Wunsequenced]

But a shape where whether it is the same object is decided only at run time — two pointers to the same object, as in *p = (*q)++ with p == q — is caught by neither. So the practical rule is the one from chapter 34 — within one full expression, change an object only once, and do not read an object you are changing elsewhere in the same expression. If the order matters, split the statement. The end of a statement is the surest sequence point.

52.17 The grey zones gathered#

Only the operator-related entries, sorted by chapter 56′s three words. The full lists are in Annex J of the standard.

52.17.1 Undefined behaviour (UB)#

52.17.2 Unspecified#

52.17.3 Implementation-defined#

52.18 Things that are not operators#

The same characters appear in the grammar without being operators.

You can now read an operator as a contract. The next chapter puts the bitwise ones to work (chapter 53) — the idioms, the traps, and the names C23 gave those idioms. After that come the places where the contracts get subtlest — the mathematics of approximation (chapter 54), handling failure (chapter 55), and what happens when a contract is broken (chapter 56).