标题：运算符优先级
语言
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
1 [ ] 数组下标 左 array_name[expr]
. 成员选择 左 object.member
( ) 方法参数 左 method_name(expr_list)
( ) 实例构造 左 class_name(expr_list)
++ 后缀自增 左 lvalue++
-- 后缀自减 左 lvalue--
2 ++ 前缀自增 右 ++rvalue
-- 前缀自减 右 --lvalue
~ 按位取反 右 ~expr
! 逻辑非 右 !expr
+ 一元加 右 +expr
- 一元减 右 -expr
3 ( ) 强制转换 右 (type)expr
new 对象实例化 右 newtype()
newtype(expr_list)
newtype[expr]
4 * 乘 左 expr *expr
/ 除 左 expr /expr
% 求余 左 expr %expr
5 + 加 左 expr +expr
- 减 左 expr -expr
+ 字符串连接 左 strExpr +strExpr
6 >> 有符号右移 左 expr >>distance
>>> 无符号右移 左 expr >>>distance
7 < 小于 左 expr <expr
<= 小于等于 左 expr <=expr
> 大于 左 expr >expr
>= 大于等于 左 expr >=expr
instanceof 类型比较 左 ref instanceofrefType
== 等于 左 expr ==expr
!= 不等于 左 expr !=expr
8 & 整数按位与 左 integralExpr &integralExpr
& 布尔与 左 booleanExpr &booleanExpr
9 ^ 整数按位异或 左 integralExpr ^integralExpr
^ 布尔异或 左 booleanExpr ^booleanExpr
10 | 整数按位或 左 integralExpr |integralExpr
| 布尔或 左 booleanExpr |booleanExpr
11 && 逻辑与 左 booleanExpr &&booleanExpr
12 || 逻辑或 左 booleanExpr ||booleanExpr
13 ?: 条件运算 右 booleanExpr ?expr : expr
14 = 赋值 右 lvalue =expr
*= 乘赋值 右 lvalue *=expr
/= 除赋值 右 lvalue /=expr
%= 模赋值 右 lvalue %=expr
+= 加赋值 右 lvalue +=expr
+= 字符串连接赋值 右 lvalue +=expr
-= 减赋值 右 lvalue -=expr
<<= 左移赋值 右 lvalue <<=expr
>>= 有符号右移赋值 右 lvalue >>=expr
>>>= 无符号右移赋值 右 lvalue >>>=expr
&= 整数按位与赋值 右 lvalue &=expr
&= 布尔与赋值 右 lvalue &=expr
|= 整数按位或赋值 右 lvalue |=expr
|= 布尔或赋值 右 lvalue |=expr
^= 整数按位异或赋值 右 lvalue ^=expr
^= 布尔异或赋值 右 lvalue ^=expr
15 　, 逗号 右 lvalue ，expr
优先级
优先级从上到下依次递减，最上面具有最高的优先级，逗号操作符具有最低的优先级。
所有的优先级中，只有三个优先级是从右至左结合的，它们是单目运算符、条件运算符、赋值运算符。其它的都是从左至右结合。
具有最高优先级的其实并不算是真正的运算符，它们算是一类特殊的操作。()是与函数相关，[]与数组相关，而－>及.是取结构成员。
其次是单目运算符，所有的单目运算符具有相同的优先级，因此在我认为的 真正的运算符中它们具有最高的优先级，又由于它们都是从右至左结合的，因此*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
赋值
= *= /= %= += －= <<= >>= &= ^= |=