请输入您要查询的百科知识:

 

词条 运算符优先级
释义

语言操作符

c语言的操作符共有15个优先级,如下:

Operators Associativity

------------------------------------------------------------------

运算符 结合性

------------------------------------------------------------------

() [] -> . left to right

! ~ ++ -- + - * sizeof(type) 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

C#中的优先级

优先级 类别 运算符

1 基本 (x) x.y f(x) a[x] x++ x――new typeof sizeof checked unchecked

2 单目 + - ! ~ ++x ――x (T)x

3 乘法与除法 * / %

4 加法与减法 + -

5 移位运算 << >>

6 关系运算 ﹤ > <= >= is

7 条件等 = = ! =

8 位逻辑与 &

9 位逻辑异或 ^

10 位逻辑或 |

11 条件与 &&

12 条件或 ‖

13 条件 ?:

14 赋值 = *= /= %= += -= <<= >>= &= ^= |=

随便看

 

百科全书收录4421916条中文百科知识,基本涵盖了大多数领域的百科知识,是一部内容开放、自由的电子版百科全书。

 

Copyright © 2004-2023 Cnenc.net All Rights Reserved
更新时间:2025/3/3 18:27:09