# C Operator Precedence

< c‎ | language

The following table lists the precedence and associativity of C operators. Operators are listed top to bottom, in descending precedence.

Precedence Operator Description Associativity
1 `++` `--` Suffix/postfix increment and decrement Left-to-right
`()` Function call
`[]` Array subscripting
`.` Structure and union member access
`->` Structure and union member access through pointer
`(type){list}` Compound literal(C99)
2 `++` `--` Prefix increment and decrement Right-to-left
`+` `-` Unary plus and minus
`!` `~` Logical NOT and bitwise NOT
`(type)` Type cast
`*` Indirection (dereference)
`&` Address-of
`sizeof` Size-of
`_Alignof` Alignment requirement(C11)
3 `*` `/` `%` Multiplication, division, and remainder Left-to-right
4 `+` `-` Addition and subtraction
5 `<<` `>>` Bitwise left shift and right shift
6 `<` `<=` For relational operators < and ≤ respectively
`>` `>=` For relational operators > and ≥ respectively
7 `==` `!=` For relational = and ≠ respectively
8 `&` Bitwise AND
9 `^` Bitwise XOR (exclusive or)
10 `|` Bitwise OR (inclusive or)
11 `&&` Logical AND
12 `||` Logical OR
13[note 1] `?:` Ternary conditional[note 2] Right-to-Left
14 `=` Simple assignment
`+=` `-=` Assignment by sum and difference
`*=` `/=` `%=` Assignment by product, quotient, and remainder
`<<=` `>>=` Assignment by bitwise left shift and right shift
`&=` `^=` `|=` Assignment by bitwise AND, XOR, and OR
15 `,` Comma Left-to-right
1. Fictional precedence level, see Notes below
2. The expression in the middle of the conditional operator (between `?` and `:`) is parsed as if parenthesized: its precedence relative to `?:` is ignored.

When parsing an expression, an operator which is listed on some row will be bound tighter (as if by parentheses) to its arguments than any operator that is listed on a row further below it. For example, the expression *p++ is parsed as *(p++), and not as (*p)++.

Operators that are in the same cell (there may be several rows of operators listed in a cell) are evaluated with the same precedence, in the given direction. For example, the expression a=b=c is parsed as a=(b=c), and not as (a=b)=c because of right-to-left associativity.

### Notes

Precedence and associativity are independent from order of evaluation.

The C language standard doesn't specify operator precedence. It specifies the language grammar, and the precedence table is derived from it to simplify understanding. There is a part of the grammar that cannot be represented by a precedence table: an assignment-expression is not allowed as the right hand operand of a conditional operator, so e = a < d ? a++ : a = d is an expression that cannot be parsed, and therefore relative precedence of conditional and assignment operators cannot be described easily.

However, many C compilers use non-standard expression grammar where `?:` is designated higher precedence than `=`, which parses that expression as e = ( ((a < d) ? (a++) : a) = d ), which then fails to compile due to semantic constraints: `?:` is never lvalue and `=` requires a modifiable lvalue on the left. This is the table presented on this page.

Note that this is different in C++, where the conditional operator has the same precedence as assignment.

Associativity specification is redundant for unary operators and is only shown for completeness: unary prefix operators always associate right-to-left (sizeof ++*p is sizeof(++(*p))) and unary postfix operators always associate left-to-right (a[1][2]++ is ((a[1])[2])++). Note that the associativity is meaningful for member access operators, even though they are grouped with unary postfix operators: a.b++ is parsed (a.b)++ and not a.(b++).

### References

• C11 standard (ISO/IEC 9899:2011):
• A.2.1 Expressions
• C99 standard (ISO/IEC 9899:1999):
• A.2.1 Expressions
• C89/C90 standard (ISO/IEC 9899:1990):
• A.1.2.1 Expressions

Order of evaluation of operator arguments at run time.

Common operators
assignment increment
decrement
arithmetic logical comparison member
access
other

a = b
a += b
a -= b
a *= b
a /= b
a %= b
a &= b
a |= b
a ^= b
a <<= b
a >>= b

++a
--a
a++
a--

+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b

!a
a && b
a || b

a == b
a != b
a < b
a > b
a <= b
a >= b

a[b]
*a
&a
a->b
a.b

a(...)
a, b
(type) a
? :
sizeof
_Alignof
(since C11)

 C++ documentation for C++ operator precedence