运算符优先级 发表评论(0) 编辑词条

运算符优先级

　　c语言的操作符共有15个优先级，如下：
　　Operators Associativity
　　() [] -> . left to right
　　! ~ ++ -- + - * (type) sizeof right to left
　　* / % left to right
　　+ - left to right
　　<< >> left to right
　　< <= > >= left to right
　　== != left to right
　　& left to right
　　^ left to right
　　| left to right
　　&& left to right
　　|| left to right
　　?: right to left
　　= += -= *= /= %= &= ^= |= <<= >>= right to left
　　, left to right
　　优先级从上到下依次递减，最上面具有最高的优先级，逗号操作符具有最低的优先级。
　　所有的优先级中，只有三个优先级是从右至左结合的，它们是单目运算符、条件运算符、赋值运算符。其它的都是从左至右结合。
　　具有最高优先级的其实并不算是真正的运算符，它们算是一类特殊的操作。()是与函数相关，[]与数组相关，而－>及.是取结构成员。
　　其次是单目运算符，所有的单目运算符具有相同的优先级，因此在我认为的 真正的运算符中它们具有最高的优先级，又由于它们都是从右至左结合的，因此*p++与*(p++)等效是毫无疑问的。
　　接下来是算术运算符，*、/、%的优先级当然比+、－高了。
　　移位运算符紧随其后。
　　其次的关系运算符中，< <= > >=要比 == !=高一个级别，不大好理解。
　　所有的逻辑操作符都具有不同的优先级（单目运算符出外，！和~）
　　逻辑位操作符的"与"比"或"高，而"异或"则在它们之间。
　　跟在其后的&&比||高。
　　接下来的是条件运算符，赋值运算符及逗号运算符。
　　在C语言中，只有4个运算符规定了运算方向，它们是&&、| |、条件运算符及赋值运算符。
　　&&、| |都是先计算左边表达式的值，当左边表达式的值能确定整个表达式的值时，就不再计算右边表达式的值。如 a = 0 && b; &&运算符的左边位0，则右边表达式b就不再判断。
　　在条件运算符中。如a?b:c；先判断a的值，再根据a的值对b或c之中的一个进行求值。
　　赋值表达式则规定先对右边的表达式求值，因此使 a = b = c = 6;成为可能。
　　C++运算符优先级
　　Operator Description Example Overloadable
Group 1 (no associativity)
:: Scope resolution operator Class::age = 2; NO
Group 2
() Function call isdigit('1') YES
() 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
const_cast Special cast const_cast(type_from); NO
dynamic_cast Special cast dynamic_cast(type_from); NO
static_cast Special cast static_cast(type_from); NO
reinterpret_cast Special cast reinterpret_cast(type_from); NO
typeid Runtime type information cout « typeid(var).name();
　　cout « typeid(type).name(); NO
Group 3 (right-to-left associativity)
! Logical negation if( !done ) … YES
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
new Dynamic memory allocation long *pVar = new long;
　　MyClass *ptr = new MyClass(args); YES
new [] Dynamic memory allocation of array long *array = new long[n]; 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
sizeof Return size of an object or type int size = sizeof floatNum;
　　int size = sizeof(float); NO
Group 4
->* Member pointer selector ptr->*var = 24; YES
.* Member object selector obj.*var = 24; NO
Group 5
* Multiplication int i = 2 * 4; YES
/ Division float f = 10.0 / 3.0; YES
% Modulus int rem = 4 % 3; YES
Group 6
+ Addition int i = 2 + 3; YES
- Subtraction int i = 5 - 1; YES
Group 7
<< Bitwise shift left int flags = 33 << 1; YES
>> Bitwise shift right int flags = 33 >> 1; YES
Group 8
< Comparison less-than if( i < 42 ) … YES
<= 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
Group 9
== Comparison equal-to if( i == 42 ) ... YES
eq Alternate spelling for ==
!= Comparison not-equal-to if( i != 42 ) … YES
not_eq Alternate spelling for !=
Group 10
& Bitwise AND flags = flags & 42; YES
bitand Alternate spelling for &
Group 11
^ Bitwise exclusive OR (XOR) flags = flags ^ 42; YES
xor Alternate spelling for ^
Group 12
| Bitwise inclusive (normal) OR flags = flags | 42; YES
bitor Alternate spelling for |
Group 13
&& Logical AND if( conditionA && conditionB ) … YES
and Alternate spelling for &&
Group 14
|| Logical OR if( conditionA || conditionB ) ... YES
or Alternate spelling for ||
Group 15 (right-to-left associativity)
? : Ternary conditional (if-then-else) int i = (a > b) ? a : b; NO
Group 16 (right-to-left associativity)
= Assignment operator int a = b; YES
+= 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
Group 17
throw throw exception throw EClass(“Message”); NO
Group 18
, Sequential evaluation operator for( i = 0, j = 0; i < 10; i++, j++ ) … YES