Operator Precedence

Relative Rank of C99 Operators

Introduction

It is important to understand the behaviour of operators as a two step process:

1. Perform a task (the name of the operator is indicative).
2. Result in a value / return a value.

Once that is understood, it is then simple to explain the difference between, for example, the pre-increment and post-increment operators: They perform the exact same task or job, but pro­duce different results. So, if the return value is not used in an expression, it is irrelevant whether the pre-, or post-fix operator is used.

Definition — Side-effect

Some operators have a side-effect, which means that, as part of the task they perform, they (also) modify memory.

Operand Types & Returns

All operators have rules regarding the type of their operands. Some operators require operands of the same type, like the arithmetic operators. The compiler will promote a smaller ranked type to the other operand's type, before the operator is invoked. The result will be the type of the op­e­rand with the highest ranked type.

Most operators return rvalues, i.e., values that cannot be modified. Only a few, like the in­di­rec­tion op­e­ra­tor, can potentially result in lvalues (expressions representing modifiable memory). Con­cep­tu­ally, you can think of operators as functions returning values. Some operators, like mem­ber se­lec­tion, and indirect member selection, will return lvalues, if the left hand operand is an lvalue, or points to an lvalue. Subscripting is just indirection in disguise, so all rules relating to indirection, also ap­ply to sub­script­ing, such as: produce lvalues, if the left hand operand is a not a void* type, or a const T* type.

Operand Association or Grouping

When the compiler must choose between two operators with the same level of precedence, it con­sid­ers how they associate with respect to their operands: from left-to-right, or right-to-left, and choose the first operator to create code for, on that basis. Most operators associate from left-to-right. Sig­ni­f­i­cant­ly, the assignment operators, and the unary prefix operators, associate from right-to-left. This is illustrated in the following code extract:

a = b = c = 0;

The expression in the last statement is evaluated as follows:

(a = (b = (c = 0)));

On the other hand, postfix inc/decrement has higher precedence than indirection, so as­so­cia­tion does not apply in the following expression:

x = *p++;
x = *(p++); // same

However, prefix inc/decrement and indirection have the same precedence, therefore op­e­rand association does play a role:

x = ++*p;  // evaluated as: `++(*p)`
x = *++p;  // evaluated as: `*(++p)`

Understanding operand association direction, is as important as understanding and learning the op­e­ra­tor precedence table.

Sequence Guarantees

It is important to understand that many operators, in particular the arithmetic operators, do not pro­vide any standardised order of evaluation of the operands. In the following code extract, which of the two operand expressions are evaluated first, f() or g(), is implementation defined. That is be­cause the addition operator does not provide a sequence guarantee. Neither of the func­tions should depend on side-effects caused by the other.

int result = f() + g();

A handful of operators provide a sequence guarantee: && (logical AND), || (logical OR), , (com­ma), and ?: (conditional). Their left hand operands are guaranteed to be evaluated first.

bool result = f() && g();

In the above statement, the f() expression is guaranteed to be evaluated first, because of the se­quen­ce guarantee provided by the logical OR operator (&&).

The binary logical operators, and the conditional operator, do not automatically evaluate all their operands. For the two logical operators (&& and ||), the right hand operand is only eva­lu­at­ed if the result cannot be determined from the first operand. This is called short-circuiting.

The conditional operator takes three operands. The result of the operator, will be either the re­sult of the 2nd ope­rand, or the 3rd operand, based on the logical value of the 1st operand. It there­for only ever evaluates two operands, the first, and based in its result, one of the other two.

The comma operator is easily abused, leading to unreadable and buggy code, and should be only be used in well-established, recognisable, patterns.

Operator Precedence Table

Arranged in decreasing priority. Operators on the same level, have the same association.

Knowing your operator precedence table is the secret to a happy life.