说明：

同一优先级的运算符，运算次序由结合方向所决定。

一、C语言操作符优先级：

优先级

运算符

名称或含义

使用形式

结合方向

说明

1

[]

数组下标

数组名[常量表达式]

左到右

-----

()

圆括号

（表达式）/函数名(形参表)

-----

.

成员选择（对象）

对象.成员名

-----

->

成员选择（指针）

对象指针->成员名

-----

2

-

负号运算符

-表达式

右到左

单目运算符

(类型)

强制类型转换

(数据类型)表达式

-----

++

前置自增运算符

++变量名

单目运算符

++

后置自增运算符

变量名++

单目运算符

--

前置自减运算符

--变量名

单目运算符

--

后置自减运算符

变量名--

单目运算符 [4] 

*

取值运算符

*指针变量

单目运算符

&

取地址运算符

&变量名

单目运算符

!

逻辑非运算符

!表达式

单目运算符

~

按位取反运算符

~表达式

单目运算符

sizeof

长度运算符

sizeof(表达式)

-----

3

/

除

表达式/表达式

左到右

双目运算符

*

乘

表达式*表达式

双目运算符

%

余数（取模）

整型表达式/整型表达式

双目运算符

4

+

加

表达式+表达式

左到右

双目运算符

-

减

表达式-表达式

双目运算符

5

<<

左移

变量

左到右

双目运算符

>>

右移

变量>>表达式

双目运算符

6

>

大于

表达式>表达式

左到右

双目运算符

>=

大于等于

表达式>=表达式

双目运算符

<

小于

表达式

双目运算符

<=

小于等于

表达式

双目运算符

7

==

等于

表达式==表达式

左到右

双目运算符

!=

不等于

表达式!= 表达式

双目运算符

8

&

按位与

表达式&表达式

左到右

双目运算符

9

^

按位异或

表达式^表达式

左到右

双目运算符

10

|

按位或

表达式|表达式

左到右

双目运算符

11

&&

逻辑与

表达式&&表达式

左到右

双目运算符

12

||

逻辑或

表达式||表达式

左到右

双目运算符

13

?:

条件运算符

表达式1? 表达式2: 表达式3

右到左

三目运算符

14

=

赋值运算符

变量=表达式

右到左

-----

/=

除后赋值

变量/=表达式

-----

*=

乘后赋值

变量*=表达式

-----

%=

取模后赋值

变量%=表达式

-----

+=

加后赋值

变量+=表达式

-----

-=

减后赋值

变量-=表达式

-----

<<=

左移后赋值

变量

-----

>>=

右移后赋值

变量>>=表达式

-----

&=

按位与后赋值

变量&=表达式

-----

^=

按位异或后赋值

变量^=表达式

-----

|=

按位或后赋值

变量|=表达式

-----

15

,

逗号运算符

表达式,表达式,…

左到右

从左向右顺序运算

举例：

以下的arr[(*size)++]，如果改为arr[*size++]，则会自右向左结合，虽然是后置自增，会先解引用，但是随后的后置自增会是地址的自增而不是size值的自增，因而会发生错误。

#include <stdio.h>
#include<stdlib.h>
#include<string.h>
void ParseArray(char *str,int *arr,int *size){char *token = strtok(str,",");*size = 0;while(token!=NULL){arr[(*size)++] = atoi(token);token = strtok(NULL,",");}
}
int main(){char str[100];int array[50];int size=0;fgets(str,sizeof(str),stdin);//从输入的字符串中根据逗号分隔取得数字存到array数组ParseArray(str,array,&size);	
}

而以下代码：
*a++会先执行后置自增，然后解引用，但是后置自增是等到解引用之后，才会执行，所以最终输出a[0]的值，然后指针偏移到a[1]，这是执行*++a，先自增，由于是前置自增，所以直接偏移到a[2]，然后解引用，输出7。

#include<stdio.h>
#include<stdlib.h>
int main(){int *a;a = (int *)malloc(sizeof(int)*40);a[0]=5;a[1]=6;a[2]=7;printf("%d",*a++); //5printf("\n")printf("%d",*++a); //7
}

二、C++操作符优先级：

运算符

描述

例子

可重载性

第一级别

-----

-----

-----

::

作用域解析符

Class::age = 2;

不可重载

第二级别

-----

-----

-----

()

函数调用

isdigit('1')

可重载

()

成员初始化

c_tor(int x, int y) : _x(x), _y(y*10){};

可重载

[]

数组数据获取

array[4] = 2;

可重载

->

指针型成员调用

ptr->age = 34;

可重载

.

对象型成员调用

obj.age = 34;

不可重载

++

后自增运算符

for( int i = 0; i < 10; i++ ) cout

可重载

--

后自减运算符

for( int i = 10; i > 0; i-- ) cout

可重载

const_cast

特殊属性转换

const_cast(type_from);

不可重载

dynamic_cast

特殊属性转换

dynamic_cast(type_from);

不可重载

static_cast

特殊属性转换

static_cast(type_from);

不可重载

reinterpret_cast

特殊属性转换

reinterpret_cast(type_from);

不可重载

typeid

对象类型符

cout « typeid(var).name();

cout « typeid(type).name();

不可重载

第三级别(具有右结合性)

-----

-----

-----

!

逻辑取反

if( !done ) …

可重载

not

! 的另一种表达

-----

-----

~

按位取反

flags = ~flags;

可重载

compl

~的另一种表达

-----

-----

++

预自增运算符

for( i = 0; i < 10; ++i ) cout

可重载

--

预自减运算符

for( i = 10; i > 0; --i ) cout

可重载

-

负号

int i = -1;

可重载

+

正号

int i = +1;

可重载

*

指针取值

int data = *intPtr;

可重载

&

值取指针

int *intPtr = &data;

可重载

new

动态元素内存分配

long *pVar = new long;

MyClass *ptr = new MyClass(args);

可重载

new []

动态数组内存分配

long *array = new long[n];

可重载

delete

动态析构元素内存

delete pVar;

可重载

delete []

动态析构数组内存

delete [] array;

可重载

(type)

强制类型转换

int i = (int) floatNum;

可重载

sizeof

返回类型内存

int size = sizeof floatNum;

int size = sizeof(float);

不可重载

第四级别

-----

-----

-----

->*

类指针成员引用

ptr->*var = 24;

可重载

.*

类对象成员引用

obj.*var = 24;

不可重载

第五级别

-----

-----

-----

*

乘法

int i = 2 * 4;

可重载

/

除法

float f = 10.0 / 3.0;

可重载

%

取余数(模运算)

int rem = 4 % 3;

可重载

第六级别

-----

-----

-----

+

加法

int i = 2 + 3;

可重载

-

减法

int i = 5 - 1;

可重载

第七级别

-----

-----

-----

<<

位左移

int flags = 33

可重载

>>

位右移

int flags = 33 >> 1;

可重载

第八级别

-----

-----

-----

<

小于

if( i < 42 ) …

可重载

<=

小于等于

if( i

可重载

>

大于

if( i > 42 ) …

可重载

>=

大于等于

if( i >= 42 ) ...

可重载

第九级别

-----

-----

-----

==

恒等于

if( i == 42 ) ...

可重载

eq

== 的另一种表达

-----

-----

!=

不等于

if( i != 42 ) …

可重载

not_eq

!=的另一种表达

-----

-----

第十级别

-----

-----

-----

&

位且运算

flags = flags & 42;

可重载

bitand

&的另一种表达

-----

-----

第十一级别

-----

-----

-----

^

位异或运算

flags = flags ^ 42;

可重载

xor

^的另一种表达

-----

-----

第十二级别

-----

-----

-----

|

位或运算

flags = flags | 42;

可重载

bitor

|的另一种表达

-----

-----

第十三级别

-----

-----

-----

&&

逻辑且运算

if( conditionA && conditionB ) …

可重载

and

&&的另一种表达

-----

-----

第十四级别

-----

-----

-----

||

逻辑或运算

if( conditionA || conditionB ) ...

可重载

or

||的另一种表达

-----

-----

第十五级别(具有右结合性)

-----

-----

-----

? :

条件运算符

int i = (a > b) ? a : b;

不可重载

第十六级别(具有右结合性)

-----

-----

-----

=

赋值

int a = b;

可重载

+=

加赋值运算

a += 3;

可重载

-=

减赋值运算

b -= 4;

可重载

*=

乘赋值运算

a *= 5;

可重载

/=

除赋值运算

a /= 2;

可重载

%=

模赋值运算

a %= 3;

可重载

&=

位且赋值运算

flags &= new_flags;

可重载

and_eq

&= 的另一种表达

-----

-----

^=

位异或赋值运算

flags ^= new_flags;

可重载

xor_eq

^=的另一种表达

-----

-----

|=

位或赋值运算

flags |= new_flags;

可重载

or_eq

|=的另一种表达

-----

-----

<<=

位左移赋值运算

flags <<=2;

可重载

>>=

位右移赋值运算

flags >>= 2;

可重载

第十七级别

-----

-----

-----

throw

异常抛出

throw EClass(“Message”);

不可重载

第十八级别

-----

-----

-----

,

逗号分隔符

for( i = 0, j = 0; i < 10; i++, j++ ) …

可重载