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  ::

Scope resolution  Lefttoright 
2  a++ a

Suffix/postfix increment and decrement  
type() type{}

Functional cast  
a()

Function call  
a[]

Subscript  
. >

Member access  
3  ++a a

Prefix increment and decrement  Righttoleft 
+a a

Unary plus and minus  
! ~

Logical NOT and bitwise NOT  
(type)

Cstyle cast  
*a

Indirection (dereference)  
&a

Addressof  
sizeof

Sizeof^{[note 1]}  
co_await

awaitexpression (C++20)  
new new[]

Dynamic memory allocation  
delete delete[]

Dynamic memory deallocation  
4  .* >*

Pointertomember  Lefttoright 
5  a*b a/b a%b

Multiplication, division, and remainder  
6  a+b ab

Addition and subtraction  
7  << >>

Bitwise left shift and right shift  
8  <=>

Threeway comparison operator (since C++20)  
9  < <= > >=

For relational operators < and ≤ and > and ≥ respectively  
10  == !=

For equality operators = and ≠ respectively  
11  &

Bitwise AND  
12  ^

Bitwise XOR (exclusive or)  
13  

Bitwise OR (inclusive or)  
14  &&

Logical AND  
15  

Logical OR  
16  a?b:c

Ternary conditional^{[note 2]}  Righttoleft 
throw

throw operator  
co_yield

yieldexpression (C++20)  
=

Direct assignment (provided by default for C++ classes)  
+= =

Compound assignment by sum and difference  
*= /= %=

Compound assignment by product, quotient, and remainder  
<<= >>=

Compound assignment by bitwise left shift and right shift  
&= ^= =

Compound assignment by bitwise AND, XOR, and OR  
17  ,

Comma  Lefttoright 
 ↑ The operand of
sizeof
can't be a Cstyle type cast: the expression sizeof (int) * p is unambiguously interpreted as (sizeof(int)) * p, but not sizeof((int)*p).  ↑ 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 of the table above with a precedence will be bound tighter (as if by parentheses) to its arguments than any operator that is listed on a row further below it with a lower precedence. For example, the expressions std::cout << a & b and *p++ are parsed as (std::cout << a) & b and *(p++), and not as std::cout << (a & b) or (*p)++.
Operators that have the same precedence are bound to their arguments in the direction of their associativity. For example, the expression a = b = c is parsed as a = (b = c), and not as (a = b) = c because of righttoleft associativity of assignment, but a + b  c is parsed (a + b)  c and not a + (b  c) because of lefttoright associativity of addition and subtraction.
Associativity specification is redundant for unary operators and is only shown for completeness: unary prefix operators always associate righttoleft (delete ++*p is delete(++(*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++).
Operator precedence is unaffected by operator overloading. For example, std::cout << a ? b : c; parses as (std::cout << a) ? b : c; because the precedence of arithmetic left shift is higher than the conditional operator.
[edit] Notes
Precedence and associativity are compiletime concepts and are independent from order of evaluation, which is a runtime concept.
The standard itself doesn't specify precedence levels. They are derived from the grammar.
const_cast, static_cast, dynamic_cast, reinterpret_cast, typeid, sizeof..., noexcept and alignof are not included since they are never ambiguous.
Some of the operators have alternate spellings (e.g., and for &&
, or for 
, not for !
, etc.).
In C, the ternary conditional operator has higher precedence than assignment operators. Therefore, the expression e = a < d ? a++ : a = d, which is parsed in C++ as e = ((a < d) ? (a++) : (a = d)), will fail to compile in C due to grammatical or semantic constraints in C. See the corresponding C page for details.
[edit] See also
Common operators  

assignment  increment decrement 
arithmetic  logical  comparison  member access 
other 
a = b 
++a 
+a 
!a 
a == b 
a[b] 
a(...) 
Special operators  
static_cast converts one type to another related type 
C documentation for C operator precedence
