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.

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.

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 you can overload an operator in such a way it can either obfuscate or just downright break your program. Use carefully.

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 is  a pointer to 'this'.
         int operator+ (const myClass & rhs);
 
       private:
         int myData;
     }