C语言c语言操作符的事先级

 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_to>(type_from); NO
dynamic_cast Special cast dynamic_cast<type_to>(type_from); NO
static_cast Special cast static_cast<type_to>(type_from); NO
reinterpret_cast Special cast reinterpret_cast<type_to>(type_from); NO
typeid Runtime type information cout &laquo; typeid(var).name();

  cout &laquo; 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