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 | ||
| () | Grouping operator | (a + b) / 4; |
| [] | 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; |
| Group 3 (right-to-left associativity) | ||
| ! | Logical negation | if( !done ) … |
| ~ | Bitwise complement | flags = ~flags; |
| ++ | 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; |
| (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 geater-than-or-equal-to | if( i >= 42 ) ... |
| Group 9 | ||
| == | Comparison equal-to | if( i == 42 ) ... |
| != | Comparison not-equal-to | if( i != 42 ) … |
| Group 10 | ||
| & | Bitwise AND | flags = flags & 42; |
| Group 11 | ||
| ^ | Bitwise exclusive OR (XOR) | flags = flags ^ 42; |
| Group 12 | ||
| | | Bitwise inclusive (normal) OR | flags = flags | 42; |
| Group 13 | ||
| && | Logical AND | if( conditionA && conditionB ) … |
| Group 14 | ||
| || | Logical OR | if( conditionA || conditionB ) ... |
| Group 15 | ||
| ? : | 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; |
| ^= | Bitwise exclusive or (XOR) and assign | flags ^= new_flags; |
| |= | Bitwise normal OR and assign | flags |= new_flags; |
| <<= | Bitwise shift left and assign | flags <<= 2; |
| >>= | Bitwise shift right and assign | flags >>= 2; |
| Group 17 | ||
| , | Sequential evaluation operator | for( i = 0, j = 0; i < 10; i++, j++ ) … |
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.