Operator precedence describes the order in which the C compiler parses operators within a compound expression. For simple expressions with a single operator, such as x + y, operator precedence does not matter, but in compound expressions, such as x + y * z, precedence matters because operator* has higher precedence than operator+ and is therefore parsed as x + (y * z). Operator precedence also takes into account the associativity of operators. For instance, in the expression w = x + y + z, operator= has right-to-left associativity while operator+ has left-to-right associativity. However, operator+ has higher precedence so the expression is parsed as if it were written w = ((x + y) + z).

Note the operator precedence and associativity have no bearing on the order of evaluation because there is no concept of left-to-right or right-to-left order of evaluation in C. That is, the expression x() + y() + z() has left-to-right associativity and will be parsed as (x() + y()) + z(), however the z() operand can be evaluated at any time without affecting the logic of the expression (assuming z() has no side-effects). If we suppose that x() evaluates z() as part of its own evaluation, then it follows that z() would be evaluated twice. But if the compiler evaluates z() first, then it can optimise away the duplicate evaluation and thus produce more efficient code.

There are 15 levels of precedence ranging from 1 (highest precedence) to 15 (lowest precedence). Operators with the same precedence are parsed according to their associativity (left-to-right or right-to-left). Note that parenthesis can be used to override operator precedence.

Operators with precedence level 1 have left-to-right associativity:

++ -- postfix increment and decrement

() function call

[] array subscripting

. structure and union member access

-> structure and union member access via pointer

(type){list} compound literal (C99)

Operators with precedence level 2 have right-to-left associativity:

++ -- prefix increment and decrement

+ - unary plus and minus

! ~ logical and bitwise NOT

(type) type case

* indirection

& address-of

sizeof size-of

_Alignof alignment requirement (C11)

Operators with precedence level 3 through 12 have left-to-right associativity:

Level 3:

* / % multiplication, division and modulo

Level 4:

+ - binary addition and subtraction

Level 5:

<< >> bitwise left and right shift

Level 6:

< <= less-than and less-than-or-equal

> >= greater-than and greater-than-or-equal

Level 7:

== != equal and not equal

Level 8:

& bitwise AND

Level 9:

^ bitwise XOR

Level 10:

| bitwise OR

Level 11:

&& logical AND

Level 12:

logical OR

Operators with precedence levels 13 and 14 have right-to-left associativity:

Level 13:

? : ternary conditional

Level 14:

= assignment

+= -= assignment by sum and difference

*= /= %= assignment by product, quotient and remainder

<<= >>= assignment by bitwise left and right shift

&= ^= |= assignment by bitwise AND, XOR and OR

Operators with precedence level 15 have left-to-right associativity:

Level 15:

, comma

Resources

Top Categories

Product

Company