運算符優先級[zz]

http://www.cppreference.com/wiki/operator_precedence

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	none
2	() () [] -> . ++ --	Function call Member initalization  Array access Member access from a pointer Member access from an object Post-increment Post-decrement	isdigit('1') c_tor(int x, int y) : _x(x), _y(y*10){}; array[4] = 2; ptr->age = 34; obj.age = 34; for( int i = 0; i < 10; i++ ) cout << i; for( int i = 10; i > 0; i-- ) cout << i;	yes yes yes yes no yes yes	left to right
3	! not ~ compl ++ -- - + * & new new [] delete delete [] (type)	Logical negation Alternate spelling for !  Bitwise complement Alternate spelling for ~  Pre-increment Pre-decrement Unary minus Unary plus Dereference Address of Dynamic memory allocation Dynamic memory allocation of array Deallocating the memory Deallocating the memory of array Cast to a given type	if( !done ) … flags = ~flags; for( i = 0; i < 10; ++i ) cout << i; for( i = 10; i > 0; --i ) cout << i; int i = -1; int i = +1; int data = *intPtr; int *intPtr = &data; long *pVar = new long;  long *array = new long[20]; delete pVar; delete [] array; int i = (int) floatNum;	yes yes yes yes yes yes yes yes yes yes yes yes yes	right to left
4	->* .*	Member pointer selector Member object selector	ptr->*var = 24; obj.*var = 24;	yes no	left to right
5	* / %	Multiplication Division Modulus	int i = 2 * 4; float f = 10.0 / 3.0; int rem = 4 % 3;	yes yes yes	left to right
6	+ -	Addition Subtraction	int i = 2 + 3; int i = 5 - 1;	yes yes	left to right
7	<< >>	Bitwise shift left Bitwise shift right	int flags = 33 << 1; int flags = 33 >> 1;	yes yes	left to right
8	< <= > >=	Comparison less-than Comparison less-than-or-equal-to Comparison greater-than Comparison greater-than-or-equal-to	if( i < 42 ) … if( i <= 42 ) ... if( i > 42 ) … if( i >= 42 ) ...	yes yes yes yes	left to right
9	== eq != not_eq	Comparison equal-to Alternate spelling for ==  Comparison not-equal-to Alternate spelling for !=	if( i == 42 ) ... if( i != 42 ) …	yes - yes	left to right
10	& bitand	Bitwise AND Alternate spelling for &	flags = flags & 42;	yes	left to right
11	^ xor	Bitwise exclusive OR (XOR) Alternate spelling for ^	flags = flags ^ 42;	yes	left to right
12	| bitor	Bitwise inclusive (normal) OR Alternate spelling for |	flags = flags | 42;	yes	left to right
13	&& and	Logical AND Alternate spelling for &&	if( conditionA && conditionB ) …	yes	left to right
14	|| or	Logical OR Alternate spelling for ||	if( conditionA || conditionB ) ...	yes	left to right
15	? :	Ternary conditional (if-then-else)	int i = (a > b) ? a : b;	no	right to left
16	= += -= *= /= %= &= and_eq ^= xor_eq |= or_eq <<= >>=	Assignment operator Increment and assign Decrement and assign Multiply and assign Divide and assign Modulo and assign Bitwise AND and assign Alternate spelling for &=  Bitwise exclusive or (XOR) and assign Alternate spelling for ^=  Bitwise normal OR and assign Alternate spelling for |= Bitwise shift left and assign Bitwise shift right and assign	int a = b; a += 3; b -= 4; a *= 5; a /= 2; a %= 3; flags &= new_flags; flags ^= new_flags; flags |= new_flags; flags <<= 2; flags >>= 2;	yes yes yes yes yes yes yes yes yes yes yes	right to left
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

Note: I removed the following, because they're not operators but functions: const_cast, dynamic_cast, reinterpret_cast, static_cast, typeid, sizeof.

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.

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.

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;
     }