| Precedence | Operator | Description | Example | Overloadable | 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 |