C++ Operator Precedence
The operators at the top of this list are evaluated first. Operators within a group have the same precedence. All operators have left-to-right associativity unless otherwise noted.
| Operator | Description | Example |
|---|---|---|
| Group 1 (no associativity) | ||
| :: | Scope resolution operator | Class::age = 2; |
| Group 2 | ||
| () | Function call | isdigit('1') |
| () | Member initalization | c_tor(int x, int y) : _x(x), _y(y*10){}; |
| [] | Array access | array[4] = 2; |
| -> | Member access from a pointer | ptr->age = 34; |
| . | Member access from an object | obj.age = 34; |
| ++ | Post-increment | for( int i = 0; i < 10; i++ ) cout << i; |
| -- | Post-decrement | for( int i = 10; i > 0; i-- ) cout << i; |
| const_cast | Special cast | const_cast<type_to>(type_from); |
| dynamic_cast | Special cast | dynamic_cast<type_to>(type_from); |
| static_cast | Special cast | static_cast<type_to>(type_from); |
| reinterpret_cast | Special cast | reinterpret_cast<type_to><type_from>; |
| typeid | Runtime type information | cout « typeid(var).name(); |
| Group 3 (right-to-left associativity) | ||
| ! | Logical negation | if( !done ) … |
| not | Alternate spelling for ! | |
| ~ | Bitwise complement | flags = ~flags; |
| compl | Alternate spelling for ~ | |
| ++ | Pre-increment | for( i = 0; i < 10; ++i ) cout << i; |
| -- | Pre-decrement | for( i = 10; i > 0; --i ) cout << i; |
| - | Unary minus | int i = -1; |
| + | Unary plus | int i = +1; |
| * | Dereference | int data = *intPtr; |
| & | Address of | int *intPtr = &data; |
| new | Dynamic memory allocation | long *pVar = new long; |
| delete | Deallocating the memory | delete pVar; |
| (type) | Cast to a given type | int i = (int) floatNum; |
| sizeof | Return size of an object | int size = sizeof(floatNum); |
| Group 4 | ||
| ->* | Member pointer selector | ptr->*var = 24; |
| .* | Member object selector | obj.*var = 24; |
| Group 5 | ||
| * | Multiplication | int i = 2 * 4; |
| / | Division | float f = 10.0 / 3.0; |
| % | Modulus | int rem = 4 % 3; |
| Group 6 | ||
| + | Addition | int i = 2 + 3; |
| - | Subtraction | int i = 5 - 1; |
| Group 7 | ||
| << | Bitwise shift left | int flags = 33 << 1; |
| >> | Bitwise shift right | int flags = 33 >> 1; |
| Group 8 | ||
| < | Comparison less-than | if( i < 42 ) … |
| <= | Comparison less-than-or-equal-to | if( i <= 42 ) ... |
| > | Comparison greater-than | if( i > 42 ) … |
| >= | Comparison greater-than-or-equal-to | if( i >= 42 ) ... |
| Group 9 | ||
| == | Comparison equal-to | if( i == 42 ) ... |
| eq | Alternate spelling for == | |
| != | Comparison not-equal-to | if( i != 42 ) … |
| not_eq | Alternate spelling for != | |
| Group 10 | ||
| & | Bitwise AND | flags = flags & 42; |
| bitand | Alternate spelling for & | |
| Group 11 | ||
| ^ | Bitwise exclusive OR (XOR) | flags = flags ^ 42; |
| xor | Alternate spelling for ^ | |
| Group 12 | ||
| | | Bitwise inclusive (normal) OR | flags = flags | 42; |
| bitor | Alternate spelling for | | |
| Group 13 | ||
| && | Logical AND | if( conditionA && conditionB ) … |
| and | Alternate spelling for && | |
| Group 14 | ||
| || | Logical OR | if( conditionA || conditionB ) ... |
| or | Alternate spelling for || | |
| Group 15 (right-to-left associativity) | ||
| ? : | Ternary conditional (if-then-else) | int i = (a > b) ? a : b; |
| Group 16 (right-to-left associativity) | ||
| = | Assignment operator | int a = b; |
| += | Increment and assign | a += 3; |
| -= | Decrement and assign | b -= 4; |
| *= | Multiply and assign | a *= 5; |
| /= | Divide and assign | a /= 2; |
| %= | Modulo and assign | a %= 3; |
| &= | Bitwise AND and assign | flags &= new_flags; |
| and_eq | Alternate spelling for &= | |
| ^= | Bitwise exclusive or (XOR) and assign | flags ^= new_flags; |
| xor_eq | Alternate spelling for ^= | |
| |= | Bitwise normal OR and assign | flags |= new_flags; |
| or_eq | Alternate spelling for |= | |
| <<= | Bitwise shift left and assign | flags <<= 2; |
| >>= | Bitwise shift right and assign | flags >>= 2; |
| Group 17 | ||
| throw | throw exception | throw EClass(“Message”); |
| Group 18 | ||
| , | Sequential evaluation operator | for( i = 0, j = 0; i < 10; i++, j++ ) … |
Order of Evaluation and of Side Effects
One important aspect of C++ that is related to operator precedence is the order of evaluation and the order of side effects in expressions. In some circumstances, the order in which things happen is not defined. For example, consider the following code:
float x = 1; x = x / ++x;
The value of x is not guaranteed to be consistent across different compilers, because it is not clear whether the computer should evaluate the left or the right side of the division first. Depending on which side is evaluated first, x could take a different value.
Furthermore, while ++x evaluates to x+1, the side effect of actually storing that new value in x could happen at different times, resulting in different values for x.
The bottom line is that expressions like the one above are horribly ambiguous and should be avoided at all costs. When in doubt, break a single ambiguous expression into multiple expressions to ensure that the order of evaluation is correct.