Expressions and assignment: precedence, side effects, short-circuit, coercion

Expressions are the basic tool of computation in a program. The exam counterpart of this topic is one sentence: “What is printed?”. Someone who knows the rules of precedence, associativity, evaluation order, short-circuiting and type conversion runs the code in their head. Someone who doesn’t guesses and loses.

Golden rules:

1. First precedence, then associativity. Operators at the same level generally go left to right; **, ?: and = go right to left.
2. Java evaluates operands from left to right. C and C++ do not guarantee this.
3. && and || do not evaluate the right side unless necessary. & and | always do.
4. x++ gives the old value, ++x gives the new value.
5. A narrowing conversion in Java happens only with a cast.

Arithmetic expressions: precedence and associativity

Operator precedence determines in which order different operators are applied. Associativity determines the order of operators at the same precedence.

System.out.println(8 - 3 * 2 + 10 / 4);   // 8 - 6 + 2
System.out.println(100 / 5 / 2 * 3);      // ((100/5)/2)*3
int a = 4, b = 9;
System.out.println(a > b ? a : b > 5 ? b * 2 : b);

4
30
18

In Python 2 ** 3 ** 2 = 2 ** 9 = 512 (associates to the right) and -3 ** 2 = -9 (** is higher than unary minus). In JavaScript too, 2 ** 3 ** 2 gives 512. APL has no precedence, everything goes from right to left: a + b * c - d = a + (b * (c - d)).

Operand evaluation order and side effects

If an operand is a variable, its value is read from memory; if it is a function call, the function runs. If the function changes another operand, the order matters. This is called a functional side effect: a function changing a parameter or a nonlocal (global) variable.

static int g = 4;
static int bump() { g = g + 3; return 2; }

int x = g * bump();   // g is read first: 4 * 2
g = 4;
int y = bump() * g;   // bump first: g = 7, then 2 * 7
System.out.println(x + " " + y + " " + g);

8 14 7

In mathematics multiplication is commutative; here it is not. Because Java and C# guarantee left to right, the result is definite. C and C++ do not specify the order: the same code may give different results with different compilers.

The language designer has two options:

1. Ban functional side effects: no two-way parameters and no nonlocal access in functions. Flexibility dies.
2. Fix the evaluation order (what Java does). Some compiler optimizations (reordering operands) become impossible.

Referential transparency: if two expressions with the same value can be substituted for each other in a program, the program is referentially transparent. In pure functional languages (Haskell) this holds naturally because there are no variables or side effects; understanding and verifying the program gets easier.

Tracing increment operators

int c = 3;
int r = c++ * 2 + --c;     // 3*2 + 3
System.out.println(r + " " + c);
int k = 10;
k -= k++ - --k;            // k = 10 - (10 - 10)
System.out.println(k);
int p = 1;
p += p++ + ++p;            // p = 1 + (1 + 3)
System.out.println(p);

9 3
10
5

Recipe: from left to right, for each operand write “what is the value now, and what happened to the variable afterward?” In a compound assignment (k -= e), the value of the variable on the left is taken before e, so changes inside e are overwritten by the final assignment.

int[] arr = {5, 6, 7};
int idx = 0;
arr[idx++] = arr[idx] + 10;
System.out.println(arr[0] + " " + arr[1] + " " + idx);

16 6 1

Java first determines the target on the left (arr[0]), idx becomes 1; then the right side is arr[1] + 10 = 16.

Overloaded operators

Using the same symbol with more than one meaning: + in Java is both addition and String concatenation. In C, & is both bitwise AND and address-of; - is both binary subtraction and unary minus. User-defined overloading (C++, C#, Python) can improve readability (a + b for matrix addition) or kill it (a class that does subtraction with +). Java does not allow user-defined overloading.

Type conversions

• Narrowing: the target type cannot hold all the values of the source (double → int, int → byte). Information may be lost.
• Widening: the target type holds all the values (at least approximately) (int → double). Generally safe; but int → float can lose precision for large numbers.
• Mixed-mode expression: operands of different types. The language either does coercion (implicit conversion) or gives an error.
• Cast: an explicit conversion written by the programmer.

int n = 5;
System.out.println(n / 2 + n / 2.0);
System.out.println((byte) 200);
System.out.println((int) -7.9 + " " + (int) 7.9);
char ch = 'a'; ch += 2;
System.out.println(ch + " " + ('a' + 2));

4.5
-56
-7 7
c 99

Coercion makes writing easier but hides type errors (reliability drops). ML and F# do no coercion at all in expressions. Java does not do narrowing coercion in assignment: int g = 3.5; does not compile.

Relational and boolean expressions

Relational operators compare two operands and produce a boolean. C89 has no boolean type; 0 is false, others are true. So a < b < c is valid in C but does not do what you think:

console.log(1 < 2 < 3, 3 > 2 > 1);
console.log("5" == 5, "5" === 5, "5" + 1, "5" - 1);

true false
true false 51 4

3 > 2 > 1: (3 > 2) = true → true > 1 → 1 > 1 → false. JavaScript’s == operator does coercion, === does not. + concatenates when it sees a String, - converts to numbers. In Java 3 > 2 > 1 does not compile.

Short-circuit evaluation

If the result is determined by the first operand, the second is not evaluated. false && X is always false, true || X is always true.

int i = 2, j = 7;
boolean r1 = (i > 5) && (++j > 0);     // skipped
boolean r2 = (i < 5) || (j++ > 0);     // skipped
boolean r3 = (i < 5) | (j++ > 100);    // ran: j = 8
boolean r4 = (i > 5) & (++j > 0);      // ran: j = 9
System.out.println(r1 + " " + r2 + " " + r3 + " " + r4 + " " + j);

false true true false 9

Short-circuiting is needed not only for speed but also for correctness:

while (k < n && list[k] != key) k++;

When k == n, list[k] is outside the array. Thanks to short-circuiting it is never read. If you write the conditions in the reverse order, the protection is lost.

Forms of assignment

my ($x, $y) = (3, 8);
($x, $y) = ($y, $x);
print "$x $y\n";

8 3

PITFALL · if (x = 0) in C. Assignment is an expression and its value is 0. C accepts any arithmetic expression as a condition: it compiles, the condition is always false and x is zeroed. In Java the condition must be a boolean, and an int does not convert to boolean: compile error. Java chose reliability here.

Common mistakes

System.out.println(8 - 3 * 2 + 10 / 4);

System.out.println(100 / 5 / 2 * 3);

int a = 4, b = 9;
int m = a > b ? a : b > 5 ? b * 2 : b;

int i = 2, j = 7;
boolean r1 = (i > 5) && (++j > 0);
boolean r2 = (i < 5) || (j++ > 0);
boolean r3 = (i < 5) | (j++ > 100);
boolean r4 = (i > 5) & (++j > 0);
System.out.println(r1 + " " + r2 + " " + r3 + " " + r4 + " " + j);

static int g = 4;
static int bump() { g = g + 3; return 2; }
// in main:
int x = g * bump();
g = 4;
int y = bump() * g;
System.out.println(x + " " + y + " " + g);

int c = 3;
int r = c++ * 2 + --c;
System.out.println(r + " " + c);

int[] arr = {5, 6, 7};
int idx = 0;
arr[idx++] = arr[idx] + 10;
System.out.println(arr[0] + " " + arr[1] + " " + idx);

int n = 5;
double d = n / 2 + n / 2.0;

System.out.println((byte) 200);
System.out.println((int) -7.9);

int k = 10;
k -= k++ - --k;
System.out.println(k);

my ($x, $y) = (3, 8);
($x, $y) = ($y, $x);
print "$x $y\n";