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

Lefttoright

()

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

Righttoleft

+ 

Unary plus and minus

! ~

Logical NOT and bitwise NOT

(type)

Type cast

*

Indirection (dereference)

&

Addressof

sizeof

Sizeof

_Alignof

Alignment requirement(C11)

3

* / %

Multiplication, division, and remainder

Lefttoright

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]}

RighttoLeft

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

Lefttoright

 ↑ Fictional precedence level, see Notes below
 ↑ 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 righttoleft 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 assignmentexpression 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 nonstandard 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 righttoleft (sizeof ++*p is sizeof(++(*p))) and unary postfix operators always associate lefttoright (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):

 C99 standard (ISO/IEC 9899:1999):

 C89/C90 standard (ISO/IEC 9899:1990):

See Also
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)
