1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
|
Operator Precedence and Associativity Rules in C / C++
============================================================================
:: scope resolution (C++, e.g. name::member) left-to-right
:: global (C++, e.g. ::name)
----------------------------------------------------------------------------
( ) function call left-to-right
[ ] array element
. class, structure or union member
-> pointer reference to member
:: scope access / resolution (C++)
sizeof size of object in bytes
sizeof size of type in bytes
----------------------------------------------------------------------------
++ post increment (lvalue++) right-to-left
++ pre increment (++lvalue)
-- post decrement (lvalue--)
-- pre decrement (--lvalue)
~ bitwise complement
! logical not
- unary minus
+ unary plus
& address of
* contents of
new create object (C++)
delete destroy object (C++)
delete[] destroy array (C++)
(type) cast to type
----------------------------------------------------------------------------
.* member pointer (C++) left-to-right
->* pointer reference to member pointer (C++)
----------------------------------------------------------------------------
* multiply left-to-right
/ divide
% remainder
----------------------------------------------------------------------------
+ add left-to-right
- subtract
----------------------------------------------------------------------------
<< bitwise left shift left-to-right
>> bitwise right shift
----------------------------------------------------------------------------
< scalar less than left-to-right
<= scalar less than or equal to
> scalar greater than
>= scalar greater than or equal to
----------------------------------------------------------------------------
== scalar equal left-to-right
!= scalar not equal
----------------------------------------------------------------------------
& bitwise and left-to-right
----------------------------------------------------------------------------
^ bitwise exclusive or left-to-right
----------------------------------------------------------------------------
| bitwise or left-to-right
----------------------------------------------------------------------------
&& logical and left-to-right
----------------------------------------------------------------------------
|| logical inclusive or left-to-right
----------------------------------------------------------------------------
? : conditional expression right-to-left
----------------------------------------------------------------------------
= assignment operator right-to-left
also += -= *= /= %=
&= ^= |= >>= <<=
----------------------------------------------------------------------------
, sequential expression left-to-right
----------------------------------------------------------------------------
All of the operators in this table can be overloaded (C++) except:
. C++ direct component selector
.* C++ dereference
:: C++ scope access/resolution
?: Conditional
|
