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

 

 

 

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

 

原文：http://www.cppreference.com/wiki/operator_precedence