The following table lists the precedence and associativity of C++ operators. Operators are listed top to bottom, in descending precedence.
 ↑ 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.
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.).
Relative precedence of the ternary conditional and assignment operators differs between C and C++: in C, assignment is not allowed on the righthand side of a ternary conditional operator, so e = a < d ? a++ : a = d cannot be parsed. Many C compilers use a modified grammar where ?:
has higher precedence than =
, which parses that as e = ( ((a < d) ? (a++) : a) = d ) (which then fails to compile because ?:
is never lvalue in C and =
requires lvalue on the left). In C++, ?:
and =
have equal precedence and group righttoleft, so that e = a < d ? a++ : a = d parses as e = ((a < d) ? (a++) : (a = d)).
See also
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[b]
*a
&a
a>b
a.b
a>*b
a.*b

a(...)
a, b
? :

Special operators

static_cast converts one type to another related type
dynamic_cast converts within inheritance hierarchies
const_cast adds or removes cv qualifiers
reinterpret_cast converts type to unrelated type
Cstyle cast converts one type to another by a mix of static_cast , const_cast , and reinterpret_cast
new creates objects with dynamic storage duration
delete destructs objects previously created by the new expression and releases obtained memory area
sizeof queries the size of a type
sizeof... queries the size of a parameter pack (since C++11)
typeid queries the type information of a type
noexcept checks if an expression can throw an exception (since C++11)
alignof queries alignment requirements of a type (since C++11)
