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 ≤ respectively  
> >=  For relational operators > and ≥ respectively  
10  == !=  For relational 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 
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)
. ?
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.
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.
Common operators  

assignment  increment decrement  arithmetic  logical  comparison  member access  other 







Special operators  

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