Precedence

It is customary in mathematics to omit parentheses to simplify complex expressions that use binary operators. For example we often write “3 + 2 + 1” instead of the more complex “(3 + 2) + 1”.

However as soon as we use different types of operators, the question immediately arises: is “1 + 2 × 3” equal to “(1 + 2) × 3” or “1 + (2 × 3)”? In mathematics at least, we use precedence rules to disambiguate: we say that “multiplication has a higher precedence than addition”, so the sign  ×  binds to its operands “tighter” than the sign  + .

Since we have multiple operators in arithmetic at least, we use a precedence table to determine which operators bind tighter than others:

Arithmetic operator	Precedence (higher binds tighter)
× ÷	4
+  −	3
=  <  >  ≤  ≥	2
⇔	1

Thanks to this table, we know that “1 < 2 + 3” is a short way to write “1 < (2 + 3)” and not “(1 < 2) + 3”, because  +  has a higher precedence than  < .

Grouping order, fixity in math

When we use the same operator two or more times, another question arises: should we group “1 + 2 + 3” as “(1 + 2) + 3” or as “1 + (2 + 3)”? For the  +  operator, this does not matter much, because addition is associative: we get the same value in either case. However, the situation is different with  − : we get different values for “1 − 2 − 3” if we group like this: “(1 − 2) − 3” (equals -4) or like this: “1 − (2 − 3)” (equals 2). In math there are a couple of well known operators that are not associative:  − , ÷ and exponentiation ((x^y)^z ≠ x^(yz)).

For this situation, in mathematics we nearly always choose for left fixity: when we use the same operator two or more times in a row, we start grouping from the left. This word “fixity” means “grouping order”.

Right associativity of assignments

The assignment in C, C++, Java and other languages is defined to be right-associative in order to simplify the assignment of multiple variables to the same value. So instead of writing:

x = 3;
y = 3;
z = 3;

we can write:

x = y = z = 3;

Which is equivalent to “x = (y = (z = 3))”. This works because the “result” of an assignment is the variable on the left of the equal sign. So “z = 3” sets z to the value 3 then gives z back into “y = z”, which changes y then gives y back to “x = y”. Of course all this would not work if the assignment was left-associative.

Right associativity of if-else

This is a dangerous pitfall which need particular attention. Consider the following program fragment:

int x = 1;
if (1 > 6)
   if (3 > 2)
     x = 2;
else
   x = 3;

What is the resulting value for x? The proper answer is 1, not 3! This is because if-else is right-associative: the else part must be grouped with the first “if” found from the right. So the example above is really equivalent to:

int x = 1;
if (1 > 6)
{
   if (3 > 2)
     x = 2;
   else
     x = 3;
}

Combined assignment and arithmetic

In nearly all programming languages with an assignment operator, the following pattern happens often in code:

<variable> = <variable> <operator> <value>

Where the same variable name is expressed on the left and right side of “=”. For example:

i = i + 1
a = a * 2
z = z - 3

Since this pattern is so common, most language will provide combined assignment operators of the form:

<variable> <operator>= <value>

For example in Java, C and C++ the following equivalences hold:

Operation	Equivalent to
a += b	a = a + b
a -= b	a = a - b
a /= b	a = a / b
a *= b	a = a * b
a %= b	a = a % b

Pre- and Post- increment and decrement

The C language, which Java inherits from, also has two additional operators: ++ and --. They each exist in two forms: a prefix form “++x” and a suffix form “x++”, for a total of 4 operators. They are defined as follows:

Pre-increment and pre-decrement:

Syntax:

++ <variable>

-- <variable>

Semantics:

Equivalent respectively to “<variable> += 1” and “<variable> -= 1”: the variable is incremented (resp. decremented) by 1, then the variable is returned as result into the enclosing expression.

For example:

int x = 42;
int y = ++x;
System.out.printf("%d %d\n", x, y); // prints 43 43

The prefix form is the simplest to understand at first contact, however in practice the suffix form is more commonly used:

Post-increment and post-decrement:

Syntax:

<variable> ++

<variable> --

Semantics:

1. the current value of the variable is saved.
2. the variable is incremented (resp. decremented) by 1.
3. the value saved in step #1 is returned as result into the enclosing expression.

For example:

int x = 42;
int y = x++;
System.out.printf("%d %d\n", x, y); // prints 43 42

The name “pre-increment” comes from Latin “pre” for “before”: the variable is incremented before its value is given back in the enclosing expression. In “post-increment” the variable is incremented “after” its value is given back in the enclosing expression.