编辑实验 创建词条
人大经济论坛-经管百科

运算符优先级 发表评论(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

经管百科已经为您找到更多关于“运算符优先级”的相关信息,点击查看>>

附件列表

→如果您认为本词条还有待完善,请 编辑词条

词条内容仅供参考,如果您需要解决具体问题
(尤其在法律、医学等领域),建议您咨询相关领域专业人士。
0

收藏到: Favorites  

同义词: 暂无同义词

关于本词条的评论 (共0条)发表评论>>