Table of Contents

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.


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

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 most circumstances, the order in which things happen is not specified. For example in f() + g() whether f() or g() is called first is not specified. If at least one of the functions has side effects the results may differ across compilers, different versions of the same compiler or even between multiple runs of the same compiler.

Further, the effect of certain expressions is undefined. For example, consider the following code:

    float x = 1;
    x = x / ++x;

The value of x and the rest of the behaviour of the program after evaluating this expression is undefined. The program is semantically ill-formed: x is modified twice between two consecutive sequence points.

Expressions like the one above must be avoided. When in doubt, break a large expression into multiple statements to ensure that the order of evaluation is correct.

Overloading of Operators

Overloading of operators can be very useful and very dangerous. On one hand overloading operators for a class you have created can help with logistics and readability of code. On the other hand you can overload an operator in such a way that it can either obfuscate or just downright break your program. Use carefully. In particular never overload &&, || or ,. In the overloaded context they lose the guarantee that the left operand is evaluated before the second and that there is a sequence point inbetween.

There are two ways to over load an operator: global function or class member.

Example of overloading with a global function:

     ostream& operator <<(ostream& os, const myClass& rhs);

But to be able to reach any private data within a user defined class you have to declare the global function as a friend within the definition of the class.

Example:

     class myClass {
 
       // Gives the operator << function access to 'myData'
       // (this declaration should not go in public, private or protected)
       friend ostream& operator <<(ostream& lhs, const myClass& rhs);
 
       private:
         int myData;
     }

Overloading with a class member can be done as follows:

     class myClass {
 
       public:
         // The left hand side of this operator becomes '*this'.
         int operator +(const myClass& rhs);
 
       private:
         int myData;
     }