Select Page

This is a chart I combined from various sources online and from books. You can use it to better understand which operators C++ will apply before others whenever you have an expression containing multiple operators. Most other charts say that you can override the order with parenthesis. But they leave the parenthesis out of the precedence chart. This chart fixes that by including parenthesis together with lambda syntax in the highest group.

This chart also goes into more detail than you might find elsewhere. For example, the scope resolution operator is listed here in multiple forms. Some of the information here is my interpretation. So if you find something that you don’t understand, let me know with a comment. Thanks.

C++ Operator Precedence

Operator

Name

Use

Overloadable

Arity

Group 1: no associativity (highest precedence)

( )

parenthesized expression

(expr)

no

n/a

[ ] { }

lambda

[capture-list] lambda-declaration {statement-list}

no

n/a

Group 2: no associativity

:: 

global scope

::name

no

unary

::

class scope

class::member

no

binary

::

namespace scope

namespace::member

no

binary

Group 3: left-to-right associativity

.

direct member selection

object.member

no

binary

->

indirect member selection

pointer->member

yes

binary

[ ]

subscript

pointer [expr]

object [expr]

yes

binary

( )

function call

expr (expr-list)

yes

n/a

( )

initialization

type (expr-list)

no (constructor)

n/a

{ }

uniform initialization

type {expr-list}

no (constructor)

n/a

type ( )

functional cast

type (expr)

no (operator)

n/a

type { }

functional cast

type {expr}

no (operator)

n/a

++

post increment

lvalue++

yes

unary

– –

post decrement

lvalue–

yes

unary

typeid ( )

type identification

typeid (type)

no

n/a

typeid ( )

run-time type identification

typeid (expr)

no

n/a

dynamic_cast

run-time checked conversion

dynamic_cast<type> (expr)

no

n/a

static_cast

compile-time checked conversion

static_cast<type> (expr)

no (operator)

n/a

reinterpret_cast

unchecked conversion

reinterpret_cast<type> (expr)

no

n/a

const_cast

const conversion

const_cast<type> (expr)

no

n/a

dynamic_pointer_cast

run-time checked conversion

dynamic_pointer_cast<type> (shrptr)

no

n/a

static_pointer_cast

compile-time checked conversion

static_pointer_cast<type> (shrptr)

no

n/a

reinterpret_pointer_cast

unchecked conversion

reinterpret_pointer_cast<type> (shrptr)

no

n/a

const_pointer_cast

const conversion

const_pointer_cast<type> (shrptr)

no

n/a

Group 4: right-to-left associativity

sizeof

size of object

sizeof expr

no

unary

sizeof ( )

size of type

sizeof (type)

no

unary

sizeof…

size of parameter pack

sizeof… name

no

unary

alignof ( )

alignment of type

alignof (type)

no

unary

++

pre increment

++lvalue

yes

unary

– – 

pre decrement

– -lvalue

yes

unary

~

compl

bitwise complement

~expr

compl expr

yes

unary

!

not

logical not

!expr

not expr

yes

unary

unary minus

-expr

yes

unary

+

unary plus

+expr

yes

unary

*

dereference

*expr

yes

unary

&

address-of

&lvalue

yes (not recommended)

unary

(type)

type conversion

(type) expr

no (operator)

n/a

new

allocate object

new type

yes

n/a

new ( )

allocate object and initialize

new type (expr-list)

yes

n/a

new { }

allocate object and initialize

new type {expr-list}

yes

n/a

new ( )

allocate object in-place

new (expr-list) type

yes

n/a

new ( ) ( )

allocate object in-place and initialize

new (expr-list) type (expr-list)

yes

n/a

new ( ) { }

allocate object in-place and initialize

new (expr-list) type {expr-list}

yes

n/a

new [ ] 

allocate array

new type [size]

yes

n/a

delete

deallocate object

delete pointer

yes

n/a

delete [ ] 

deallocate array

delete [ ] pointer

yes

n/a

noexcept ( )

can expression throw

noexcept (expr)

no

n/a

Group 5: left-to-right associativity

.*

direct pointer to member selection

object.*pointer-to-member

no

binary

->*

indirect pointer to member selection

pointer->*pointer-to-member

yes

binary

Group 6: left-to-right associativity

*

multiplication

expr * expr

yes

binary

/

dividision

expr / expr

yes

binary

%

modulo (remainder)

expr % expr

yes

binary

Group 7: left-to-right associativity

+

addition

expr + expr

yes

binary

subtraction

expr – expr

yes

binary

Group 8: left-to-right associativity

<<

bitwise left shift

expr << expr

yes

binary

>>

bitwise right shift

expr >> expr

yes

binary

Group 9: left-to-right associativity

<

less than

expr < expr

yes

binary

<=

less than or equal

expr  <= expr

yes

binary

>

greater than

expr > expr

yes

binary

>=

greater than or equal

expr >= expr

yes

binary

Group 10: left-to-right associativity

==

equal

expr == expr

yes

binary

!=

not_eq

not equal

expr != expr

expr not_eq expr

yes

binary

Group 11: left-to-right associativity

&

bitand

bitwise and

expr & expr

expr bitand expr

yes

binary

Group 12: left-to-right associativity

^

xor

bitwise exclusive or

expr ^ expr

expr xor expr

yes

binary

Group 13: left-to-right associativity

|

bitor

bitwise or

expr | expr

expr bitor expr

yes

binary

Group 14: left-to-right associativity

&&

and

logical and

expr && expr

expr and expr

yes

binary

Group 15: left-to-right associativity

||

or

logical or

expr || expr

expr or expr

yes

binary

Group 16: right-to-left associativity

? :

conditional

expr ? expr : conditional-expr

expr ? expr : assignment-expr

no

ternary

Group 17: right-to-left associativity

{ }

list

{expr-list}

no

n/a

=

assignment

lvalue = expr

yes

binary

*=

multiplication assignment

lvalue *= expr

yes

binary

/=

division assignment

lvalue /= expr

yes

binary

%=

modulo assignment

lvalue %= expr

yes

binary

+=

addition assignment

lvalue += expr

yes

binary

-=

subtraction assignment

lvalue -= expr

yes

binary

<<=

bitwise left shift assignment

lvalue <<= expr

yes

binary

>>=

bitwise right shift assignment

lvalue >>= expr

yes

binary

&=

and_eq

bitwise and assignment

lvalue &= expr

lvalue and_eq expr

yes

binary

|=

or_eq

bitwise or assignment

lvalue |= expr

lvalue or_eq expr

yes

binary

^=

xor_eq

bitwise exclusive or assignment

lvalue ^= expr

lvalue xor_eq expr

yes

binary

Group 18: right-to-left associativity

throw

throw exception

throw expr

no

unary

Group 19: left-to-right associativity (lowest precedence)

,

comma

expr, expr

yes (not recommended)

binary