/C

# C Operator Precedence

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.

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++` is `((a))++`). 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++)`.

• 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`