C++ has a large operator set, as the table below testifies.

When an expression involves

two or more operators, two rules are applied to determine the meaning of the expression:1. Priority - Higher priority operators take priority over lower priority ones. So, as every
FORTRAN programmer knows,:2+3*5
is 17 not 25. In the table operators are ordered in decreasing priority, although
operators within a single box, for example add and subtract, operate at the same
priority.
2. Association - When selecting between two operators of the same priority, they
operate according to their associativity, which is either: R/L (right to left). Unary operators and assignment operators are right to left. So
x=y=z
places the value z in x and y (not place y in x and z in y)
L/R (left to right). All other operators work left to right, so expressions of the form:point -> member_func1(args1) -> member_func2(args2)
where one object's member function is called, and returns a pointer to a second object
whose member function is then called.

Operator Summary
Symbol Name

Assoc.Example

::

Scope resolution

L/R

class_name::member

::

Global

L/R

::name

Member selection

L/R

object.member

->

Member selection

L/R

pointer->member

[]

Subscripting

L/R

pointer [ expr ]

()

Function call

L/R

expr ( expr_list )

()

Value contruction

L/R

type ( expr_list )

++

Post increment

R/L

lvalue++

--

Post decrement

R/L

lvalue--

sizeof
sizeof
++
-~
!
+
&

size of object
size of type
pre increment
pre decrement
complement
not
unary minus
unary plus
address of

R/L
R/L
R/L
R/L
R/L
R/L
R/L
R/L
R/L

sizeof expr
sizeof ( type )
++lvalue
--lvalue
~ expr
! expr
- expr
+ expr
& lvalue

dereference

R/L

* expr

new
delete
delete []
()

create
destroy
destroy array
type cast

R/L
R/L
R/L
R/L

new type
delete pointer
delete [] pointer
( type ) expr

Operator Summary

.*
->*

member selection
member selection

L/R object .* pointer-to-member

L/R pointer ->* pointer-to-member

*
/

multiply
divide

L/R expr * expr

L/R expr / expr

modulo

L/R expr % expr

+
-

add
subtract

L/R expr + expr

L/R expr - expr

<<
>>

shift left
shift right

L/R expr << expr

L/R expr >> expr

<
<=
>
>=

less than
less than or equal
greater than
greater than or equal

L/R
L/R
L/R
L/R

==
!=

equal
not equal

L/R expr == expr

R/L expr != expr

&

bitwise AND

L/R expr & expr

bitwise exclusive OR

R/L expr ^ expr

bitwise inclusive OR

L/R expr | expr

&&

logical AND

L/R expr && expr

||

logical inclusive OR

L/R expr || expr

?:

conditional expression

L/R expr ? expr : expr

=
*=
/=
%=
+=
-=
<<=
>>=
&=
^=
|=

simple assignment
multiply and assign
divide and assign
modulo and assign
add and assign
subtract and assign
shift left and assign
shift right and assign
AND and assign
exclusive OR and assign
inclusive OR and assign

R/L
R/L
R/L
R/L
R/L
R/L
R/L
R/L
R/L
R/L
R/L

throw

throw exception

R/L throw expr

comma

L/R expr , expr

Where:o class_name - is the name of a class.

expr < expr

expr <= expr
expr > expr
expr >= expr

lvalue = expr
lvalue *= expr
lvalue /= expr
lvalue %= expr
lvalue += expr
lvalue -= expr
lvalue <<= expr
lvalue >>= expr
lvalue &= expr
lvalue ^= expr
lvalue |= expr

o member - is a member function or a data member.

o object - is an expression producing an object.
o pointer - is an expression producing a pointer.
o expr - is an expression.
o lvalue - is an lvalue i.e. a value that can be modified.
o type - is the name of a type, either fundamental or user defined.