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^{[note 1]}  
_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 2]}  ?:  Ternary conditional^{[note 3]}  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 
sizeof
can't be a type cast: the expression sizeof (int) * p
is unambiguously interpreted as (sizeof(int)) * p
, but not sizeof((int)*p)
. ?
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.
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++)
.
Order of evaluation of operator arguments at run time.
Common operators  

assignment  increment decrement  arithmetic  logical  comparison  member access  other 







© cppreference.com
Licensed under the Creative Commons AttributionShareAlike Unported License v3.0.
http://en.cppreference.com/w/c/language/operator_precedence