| Prece dence |
Operator |
Description |
Example |
Over loadable |
Associativity |
| 1 |
:: |
Scope resolution operator |
Class::age = 2; |
no |
left to right |
| 2 |
() |
Function call |
printf(“Hello world\n”); |
yes |
left to right |
| () |
Member initalization |
c_tor(int x, int y) : _x(x), _y(y * 10) {} |
yes |
| [] |
Array access |
array[4] = 2; |
yes |
| -> |
Member access from a pointer |
ptr->age = 34; |
yes |
| . |
Member access from an object |
obj.age = 34; |
no |
| ++ |
Post-increment |
for (int i = 0; i < 10; i++) cout << i; |
yes |
| -- |
Post-decrement |
for (int i = 10; i > 0; i--) cout << i; |
yes |
| dynamic_cast |
Runtime-checked type conversion |
Y& y = dynamic_cast<Y&>(x); |
no |
| static_cast |
Unchecked type conversion |
Y& y = static_cast<Y&>(x); |
no |
| reinterpret_cast |
Reinterpreting type conversion |
int const* p = reinterpret_cast<int const*>(0x1234); |
no |
| const_cast |
Cast away/Add constness |
int* q = const_cast<int*>(p); |
no |
| typeid |
Get type information |
std::type_info const& t = typeid(x); |
no |
| 3 |
! |
Logical negation |
if (!done) ... |
yes |
right to left |
| not |
Alternate spelling for ! |
| ~ |
Bitwise complement |
flags = ~flags; |
yes |
| compl |
Alternate spelling for ~ |
| ++ |
Pre-increment |
for (i = 0; i < 10; ++i) cout << i; |
yes |
| -- |
Pre-decrement |
for (i = 10; i > 0; --i) cout << i; |
yes |
| - |
Unary minus |
int i = -1; |
yes |
| + |
Unary plus |
int i = +1; |
yes |
| * |
Dereference |
int data = *intPtr; |
yes |
| & |
Address of |
int *intPtr = &data; |
yes |
| sizeof |
Size (of the type) of the operand in bytes |
size_t s = sizeof(int); |
no |
| new |
Dynamic memory allocation |
long* pVar = new long; |
yes |
| new [] |
Dynamic memory allocation of array |
long* array = new long[20]; |
yes |
| delete |
Deallocating the memory |
delete pVar; |
yes |
| delete [] |
Deallocating the memory of array |
delete [] array; |
yes |
| (type) |
Cast to a given type |
int i = (int)floatNum; |
yes |
| 4 |
->* |
Member pointer selector |
ptr->*var = 24; |
yes |
left to right |
| .* |
Member object selector |
obj.*var = 24; |
no |
| 5 |
* |
Multiplication |
int i = 2 * 4; |
yes |
left to right |
| / |
Division |
float f = 10.0 / 3.0; |
yes |
| % |
Modulus |
int rem = 4 % 3; |
yes |
| 6 |
+ |
Addition |
int i = 2 + 3; |
yes |
left to right |
| - |
Subtraction |
int i = 5 - 1; |
yes |
| 7 |
<< |
Bitwise shift left |
int flags = 33 << 1; |
yes |
left to right |
| >> |
Bitwise shift right |
int flags = 33 >> 1; |
yes |
| 8 |
< |
Comparison less-than |
if (i < 42) ... |
yes |
left to right |
| <= |
Comparison less-than-or-equal-to |
if (i <= 42) ... |
yes |
| > |
Comparison greater-than |
if (i > 42) ... |
yes |
| >= |
Comparison greater-than-or-equal-to |
if (i >= 42) ... |
yes |
| 9 |
== |
Comparison equal-to |
if (i == 42) ... |
yes |
left to right |
| eq |
Alternate spelling for == |
| != |
Comparison not-equal-to |
if (i != 42) ... |
yes |
| not_eq |
Alternate spelling for != |
| 10 |
& |
Bitwise AND |
flags = flags & 42; |
yes |
left to right |
| bitand |
Alternate spelling for & |
| 11 |
^ |
Bitwise exclusive OR (XOR) |
flags = flags ^ 42; |
yes |
left to right |
| xor |
Alternate spelling for ^ |
| 12 |
| |
Bitwise inclusive (normal) OR |
flags = flags | 42; |
yes |
left to right |
| bitor |
Alternate spelling for | |
| 13 |
&& |
Logical AND |
if (conditionA && conditionB) ... |
yes |
left to right |
| and |
Alternate spelling for && |
| 14 |
|| |
Logical OR |
if (conditionA || conditionB) ... |
yes |
left to right |
| or |
Alternate spelling for || |
| 15 |
? : |
Ternary conditional (if-then-else) |
int i = a > b ? a : b; |
no |
right to left |
| 16 |
= |
Assignment operator |
int a = b; |
yes |
right to left |
| += |
Increment and assign |
a += 3; |
yes |
| -= |
Decrement and assign |
b -= 4; |
yes |
| *= |
Multiply and assign |
a *= 5; |
yes |
| /= |
Divide and assign |
a /= 2; |
yes |
| %= |
Modulo and assign |
a %= 3; |
yes |
| &= |
Bitwise AND and assign |
flags &= new_flags; |
yes |
| and_eq |
Alternate spelling for &= |
| ^= |
Bitwise exclusive or (XOR) and assign |
flags ^= new_flags; |
yes |
| xor_eq |
Alternate spelling for ^= |
| |= |
Bitwise normal OR and assign |
flags |= new_flags; |
yes |
| or_eq |
Alternate spelling for |= |
| <<= |
Bitwise shift left and assign |
flags <<= 2; |
yes |
| >>= |
Bitwise shift right and assign |
flags >>= 2; |
yes |
| 17 |
throw |
throw exception |
throw EClass(“Message”); |
no |
|
| 18 |
, |
Sequential evaluation operator |
for (i = 0, j = 0; i < 10; i++, j++) ... |
yes |
left to right |
