操作符详解:操作符分类、算数操作符、移位操作符（进制转换）、位操作符（按位与、按位或、按位异或）、赋值操作符、单目操作符、关系操作符、逻辑操作符、条件操作符比较较大值、隐式类型转换etc。

本文链接：https://blog.csdn.net/m0_61870512/article/details/126415574

本文详细介绍了C语言中的各种操作符，包括算术、移位、位、赋值、单目、关系、逻辑、条件和逗号操作符。深入探讨了它们的工作原理、应用场景以及潜在的陷阱，如整型提升、位运算和移位操作。还讨论了表达式求值的顺序和类型转换规则，以及在编程中需要注意的细节。

摘要由CSDN通过智能技术生成

操作符详解

文章目录

操作符详解

1. 操作符分类：

算术操作符、移位操作符、位操作符、赋值操作符、单目操作符、关系操作符、逻辑操作符、条件操作符、逗号表达式、下标引用、函数调用和结构成员

2. 算术操作符

+ - * /（商） %（余数）

除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
% 操作符的两个操作数必须为整数。返回的是整除之后的余数。

3. 移位操作符

<< 左移操作符
>> 右移操作符
注：移位操作符的操作数只能是整数。（移位操作符，移动的是二进制位，是二进制位的表示。）

3.1 进制

以数值15引出十进制、八进制、二进制的表示原理:

在这里插入图片描述

3.1.1 整型的2进制表示：

原码、反码、补码。

移位操作符，移动的是储存在内存中的补码

符号位为0，表示正数；符号位为1，表示负数
整数，在C语言可以存放到int类型变量中，int类型是4个字节，32 bit
15——正整数原码补码反码相同
00000000 00000000 00000000 00001111——原码
00000000 00000000 00000000 00001111——反码
00000000 00000000 00000000 00001111——补码
-15——原码：首位表示正负（符号位）；反码：原码的符号位不变，其它位按位取反；补码：反码+1
10000000 00000000 00000000 00001111——原码
11111111 11111111 11111111 11110000——反码
11111111 11111111 11111111 11110001——补码

实际上：整数在内存中储存的是二进制的补码。

3.2 左移操作符

移位规则：

左边抛弃、右边补0

3.2.1 正整数原理：

在这里插入图片描述

3.2.2 负整数原理：

在这里插入图片描述

3.3 右移操作符

移位规则：

在这里插入图片描述

首先右移运算分两种：

逻辑移位

左边用0填充，右边丢弃

在这里插入图片描述

算术移位（多用）

左边用原该值的符号位填充，右边丢弃

在这里插入图片描述

警告⚠ ：

对于移位运算符，不要移动负数位，这个是标准未定义的。

例如:

int num = 10;
num>>-1;//error

加法通过补码操作（减法会转化为加法）

4. 位操作符

位操作符有：

& //按位与
| //按位或
^ //按位异或
注：他们的操作数必须是整数。

4.1 按位与操作

相异为0，相同为1

在这里插入图片描述

4.2 按位或操作

只要有1就为1，两个同时为0才为0

在这里插入图片描述

4.3 按位异或操作

相同为0，相异为1

在这里插入图片描述

4.3.1 实现两个数的交换

不能创建临时变量（第三个变量），实现两个数的交换。

在这里插入图片描述

异或操作支持交换律：

在这里插入图片描述

#include <stdio.h>
int main()
{
    int a = 10;
    int b = 20;
    a = a ^ b;
    b = a ^ b;//b=a^b^b
    a = a ^ b;//a^b^a
    printf("a = %d b = %d\n", a, b);
    return 0; 
}

作为了解，可读性不强。

4.3.2 求一个整数存储在内存中的二进制中1的个数

//方法1
#include <stdio.h>
int main()
{
    int num  = 10;
    int count=  0;//计数
    while(num)
    {
        if(num%2 == 1)
           count++;
        num = num/2;
    }
    printf("二进制中1的个数 = %d\n", count);
    return 0;
}
//思考这样的实现方式有没有问题？

//方法2：
#include <stdio.h>
int main()
{
    int num = -1;
    int i = 0;
    int count = 0;//计数
    for(i=0; i<32; i++)
    {
        if( num & (1 << i) )
        count++; 
    }
    printf("二进制中1的个数 = %d\n",count);
    return 0; 
}
//思考还能不能更加优化，这里必须循环32次的。

//方法3：
#include <stdio.h>
int main()
{
    int num = -1;
    int i = 0;
    int count = 0;//计数
    while(num)
    {
        count++;
        num = num&(num-1);
    }
    printf("二进制中1的个数 = %d\n",count);
    return 0; 
}
//这种方式是不是很好？达到了优化的效果，但是难以想到。

5. 赋值操作符

赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值。

int weight = 120;//体重
weight = 89;//不满意就赋值

double salary = 10000.0;
salary = 20000.0;//使用赋值操作符赋值。

赋值操作符可以连续使用，比如：
int a = 10;
int x = 0;
int y = 20; 
a = x = y+1;//连续赋值:把右边赋给左边

同样的语义：
x = y+1; 
a = x;
这样的写法更加清晰爽朗而且易于调试。

复合赋值符

+=
-=
*=
/=
%=
>>=
<<=
&=
\|=
^=

这些运算符都可以写成复合的效果。

比如：

int x = 10; 
x = x+10; 
x += 10;//复合赋值
//其他运算符一样的道理。这样写更加简洁。

6. 单目操作符

单目操作符介绍

!           逻辑反操作
-           负值
+           正值
&           取地址
sizeof      操作数的类型长度（以字节为单位）
~           对一个数的二进制按位取反
--          前置、后置--
++          前置、后置++
*           间接访问操作符(解引用操作符) 
(类型)       强制类型转换

6.1 ！常见应用场景

int main()
{
	int flag = 0;
	if (!flag)
	//if(flag==0)
	{
		printf("wolf\n");
	}
	return 0;
}

6.2 &和*在指针里的应用

int main()
{
  //创建变量的本质：在内存中开辟空间
    int a = 10;//4
    char c = 0;//1
   // printf("%p\n", &a);
   //printf("%p\n", &c);
   
    int* pa = &a;//& - 取地址操作符
    //a为int型
    //int*为变量名
    //pa存放a的地址，地址也叫指针
    //存放地址或者指针的变量叫指针变量
    *pa;//* - 解引用操作符
    return 0;
}

注意避免野指针问题（略）

int main()
{
	//野指针问题
	*(int*)0x0012ff40 = 100;//指针解引用
	//强制类型转换
	return 0;
}

6.3 sizeof 和数组

a. sizeof

之前已经见过 sizeof ,可以求变量（类型）所占空间的大小。

关于 sizeof 后括号是否可以省略 + sizeof 相关计算

int main()
{
	int a = 10;
	int* p;
	int arr[10];

	printf("%zu\n", sizeof(a));//int  4
	printf("%zu\n", sizeof a );//括号可省略说明a是操作符而不是函数
	//（）是函数调用操作符

	printf("%zu\n", sizeof(int));//合法写法
	//放类型就是错误写法
	printf("%zu\n", sizeof int );//err 


	printf("%zu\n", sizeof(p));//int* 4
	printf("%zu\n", sizeof(arr));//int [10] ->4*10
	printf("%zu\n", sizeof(arr[0]));//sizeof(arr[10])//int  4
	return 0;
}

sizeof（）内部的表达式是不会被计算的

%zu 专门用来打印sizeof

int main()
{
	int a = 2;
	short s = 10;
	printf("%zu\n", sizeof(s = a + 5));//2
	//s为short类型——>两个字节
	//int型的a发生截断
	printf("%d\n", s);//10
	//(s = a + 5)的表达式不会被计算
	return 0;
}

原理

在这里插入图片描述

关于截断

在这里插入图片描述

b. 数组

sizeof 在指针里的应用

#include <stdio.h>
void test1(int arr[])
{
     printf("%d\n", sizeof(arr));//4=int* arr
}
void test2(char ch[])
{
     printf("%d\n", sizeof(ch));//4=char* ch
}
//所有指针类型都是一样的大小，4byte or 8byte
int main()
{
    int arr[10] = {0};
    char ch[10] = {0};
    printf("%d\n", sizeof(arr));//40=4(int)*10([10])
    printf("%d\n", sizeof(ch));//10=1(char)*10([10])
    test1(arr);
    test2(ch);
    return 0;
}

数组名：

数组名是首元素的地址。

但是有两个例外：

sizeof（数组名），数组名表示整个数组，不是首元素的地址。计算的是整个数组的大小，单位是字节。
&数组名，数组名表示整个数组，不是首元素的地址。取出的是整个数组的地址。

6.4 ~操作的常见应用场景

在这里插入图片描述

6.5 ++和–运算符

//前置++和–

#include <stdio.h>
int main()
{
    int a = 10;
    int x = ++a;
//先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。
    int y = --a;
//先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;
    return 0; 
}

//后置++和–

#include <stdio.h>
int main()
{
    int a = 10;
    int x = a++;
//先对a先使用，再增加，这样x的值是10；之后a变成11；
    int y = a--;
//先对a先使用，再自减，这样y的值是11；之后a变成10；
    return 0;
}

6.6 （类型）的应用场景

int main()
{ 
	int a = (int)3.14;
	printf("%d\n", a);//3
	return 0;
}

7. 关系操作符

关系操作符

>
>=
<
<=
!=     用于测试“不相等”
==     用于测试“相等”

这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。

警告：

在编程的过程中== 和=不小心写错，导致的错误。

故先写赋的值再写==。

8. 逻辑操作符

逻辑操作符有哪些：

&&          逻辑与
||          逻辑或

区分逻辑与和按位与

区分逻辑或和按位或

1&2----->0 
1&&2---->1
   
1|2----->3 
1||2---->1

逻辑与和或的特点：

#include <stdio.h>
int main()
{
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++ && ++b && d++;//1,2,3,4
	//&& a为假的话b的值就不用算了

	i = a++||++b||d++;//1,3,3,4
	//|| a为真的话b的值就不用算了
	printf("a = %d\n b = %d\n c = %d\nd =%d\n", a, b, c, d);
	return 0;
}

在这里插入图片描述

9. 条件操作符（三目操作符）

exp1 ? exp2 : exp3

9.1 替换if…else

if (a > 5)
        b = 3;
else
        b = -3;
转换成条件表达式
    b=((a > 5) ? 3 : -3);

9.2 比较较大值

int m=(a?b:a:b);

10. 逗号表达式

exp1 , exp2 , exp3 , … expN

逗号表达式：用逗号隔开的多个表达式。

逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。

10.1 基本理解

int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//13

10.2 条件判断语句中的应用（if、while）

//if语句
if (a =b + 1, c=a / 2, d > 0)

    
//while语句
a = get_val();
count_val(a);
while (a > 0) 
{
  //sth.
        a = get_val();
        count_val(a);
}
如果使用逗号表达式，改写：
while (a = get_val(), count_val(a), a>0) 
{
         //sth.
}

11. 下标引用、函数调用和结构成员

11.1 [ ] 下标引用操作符

操作数：一个数组名 + 一个索引值（下标）

 int arr[10];//创建数组
 arr[9] = 10;//实用下标引用操作符。
 [ ]的两个操作数是arr和9。

11.2 ( ) 函数调用操作符

接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

#include <stdio.h>
 void test1(int x, int y)
 {
    
 }
 void test2(const char *str)
 {
      printf("%s\n", str);
 }
void test3()
{
    
}
 int main()
 {
     test1(3，4);            //实用（）作为函数调用操作符。
     //操作数：test，3，4
     test2("hello LJ.");   //实用（）作为函数调用操作符。
     test3();
     //操作数：test3
     return 0;
 }

11.3 访问一个结构的成员

. ：结构体变量.成员名

-> ：结构体指针->成员名

struct Book
{
	char name[20];
	int price;
};
int main()
{
	struct Book sb = { "Ascend",35 }; 
	printf("%s %d\n", sb.name, sb.price);      //结构体变量.结构体成员名
	struct Book* ps = &sb;
	printf("%s %d\n", (*ps).name, (*ps).price);//结构体指针->结构体成员名
	printf("%s %d\n", ps->name, ps->price);
	return 0;
}

12. 表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。

同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。

12.1 隐式类型转换

C的整型算术运算总是至少以缺省整型（默认）类型的精度来进行的。

为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

整型提升的意义：

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。

因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。

通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。

所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。

12.1.1 整型提升过程讲解

int main()
{
	char a = 5;
	char b = 126;
	char c = a + b;
	//00000000 00000000 00000000 00000101
	//00000101 - a(发生截断）
	//00000000 00000000 00000000 01111110
	//01111110 - b(发生截断）
	//整型提升：
	//00000000 00000000 00000000 00000101 - a
	//00000000 00000000 00000000 01111110 - b
	//00000000 00000000 00000000 10000011 （相加）
	//10000011 - c
	printf("%d\n", c);
	//十进制的方式打印有符号的整数
	//11111111 11111111 11111111 10000011 - 补码
	//11111111 11111111 11111111 10000010 -  -1
	//11111111 11111111 11111111 10000011 - 补码
	//10000000 00000000 00000000 01111101 - 保留符号位，取反
	//-125
	return 0;
}

b和c的值被提升为普通整型，然后再执行加法运算。

加法运算完成之后，结果将被截断，然后再存储于a中。

12.1.2 整体提升规则：

整形提升是按照变量的数据类型的符号位来提升的

//负数的整形提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111

//正数的整形提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001

//无符号整形提升，高位补0

12.1.3 整型提升示例：

int main()
{
    char  a = 0xb6;
    //10110110
    //整型提升后补1，符号位1，为负数
    short b = 0xb600;
    int   c = 0xb6000000;
    if(a==0xb6)
    //整型提升后为负数，判断后不会打印
       printf("a");
    if(b==0xb600)
    //整型提升后为负数，判断后不会打印 
       printf("b");
    if(c==0xb6000000)
    //本身就是int型，不会进行整型提升
       printf("c");
    //只会打印C
       return 0; 
}

12.1.4 有表达式的整型提升：

c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof (+c) 是4个字节。

表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof© ,就是1个字节。

int main()
{
    char c = 1;
    printf("%u\n", sizeof(c));//1
    printf("%u\n", sizeof(c+1));//4
    printf("%u\n", sizeof(+c));//4
    printf("%u\n", sizeof(-c));//4
    return 0; 
}

12.2 算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。

下面的层次体系称为寻常算术转换。

long double、double、float、unsigned long int、long int、unsigned int、int

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。

💔但是算术转换要合理，要不然会有一些潜在的问题。

float f = 3.14;//double
int num = f;//隐式转换，会有精度丢失

12.3 操作符的属性

复杂表达式的求值有三个影响的因素。

操作符的优先级。
操作符的结合性。
是否控制求值顺序。

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。

12.3.1 操作符优先级：

此表从上往下，操作符顺序由高到低。

N/A不考虑结合性，L-R从左到右结合，L-R从右向左结合。

操作符	描述	用法示例	结果类型	结合性	是否控制求值顺序
（）	聚组	（表达式）	与表达式同	N/A	否
（）	函数调用	rexp（rexp，…,rexp）	rexp	L-R	否
[ ]	下标引用	rexp[rexp]	lexp	L-R	否
.	访问结构体成员	lexp.member_name	lexp	L-R	否
->	访问结构体指针成员	rexp->member_name	lexp	L-R	否
++	后缀自增	lexp++	rexp	L-R	否
–	后缀自减	lexp–	rexp	L-R	否
!	逻辑反	! rexp	rexp	R-L	否
~	按位取反	~ rexp	rexp	R-L	否
+	单目，表示正值	+ rexp	rexp	R-L	否
-	单目，表示负值	- rexp	rexp	R-L	否
++	前缀自增	++ lexp	rexp	R-L	否
–	前缀自减	– lexp	rexp	R-L	否
*	间接访问	* rexp	lexp	R-L	否
&	取地址	& lexp	rexp	R-L	否
sizeof	取其长度，以字节表示	sizeof rexp sizeof(类型)	rexp	R-L	否
(类型)	类型转换	(类型) rexp	rexp	R-L	否
*	乘法	rexp * rexp	rexp	L-R	否
/	除法	rexp / rexp	rexp	L-R	否
%	整数取余	rexp % rexp	rexp	L-R	否
+	加法	rexp + rexp	rexp	L-R	否
-	减法	rexp - rexp	rexp	L-R	否
<<	左移位	rexp << rexp	rexp	L-R	否
>>	右移位	rexp >> rexp	rexp	L-R	否
>	大于	rexp > rexp	rexp	L-R	否
>=	大于等于	rexp >= rexp	rexp	L-R	否
<	小于	rexp < rexp	rexp	L-R	否
<=	小于等于	rexp <= rexp	rexp	L-R	否
==	等于	rexp == rexp	rexp	L-R	否
!=	不等于	rexp != rexp	rexp	L-R	否
&	位与	rexp & rexp	rexp	L-R	否
^	位异或	rexp ^ rexp	rexp	L-R	否
\|	位或	rexp\|rexp	rexp	L-R	否
&&	逻辑与	rexp && rexp	rexp	L-R	是
\|\|	逻辑或	rexp\|\|rexp	rexp	L-R	是
? :	条件操作符	rexp?rexp:rexp	rexp	N/A	是
=	赋值	lexp=lexp	rexp	R-L	否
+=	以…加	lexp+=lexp	rexp	R-L	否
-=	以…减	lexp-=lexp	rexp	R-L	否
*=	以…乘	lexp *= rexp	rexp	R-L	否
/=	以…除	lexp /= rexp	rexp	R-L	否
%=	以…取模	lexp %= rexp	rexp	R-L	否
<<=	以…左移	lexp <<= rexp	rexp	R-L	否
>>=	以…右移	lexp >>= rexp	rexp	R-L	否
&=	以…与	lexp &= rexp	rexp	R-L	否
^=	以…异或	lexp ^= rexp	rexp	R-L	否
\|=	以…或	lexp\|=rexp	rexp	R-L	否
,	逗号	rexp，rexp	rexp	L-R	是

13.3.2 一些问题表达式

a. 表达式1

表达式的求值部分由操作符的优先级决定。
操作符的优先级只能决定相邻操作符的优先级。

a*b + c*d + e*f

注释：

在计算的时候，由于* 比 + 的优先级高，只能保证，* 的计算是比+早，但是优先级并不能决定第三个*比第一个+早执行。

b. 表达式2

c + --c;

注释：

同上，操作符的优先级只能决定自减–的运算在+的运算的前面，但是我们并没有办法得知，+操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义的。

c. 表达式3

int main()
{
    int i = 10;
    i = i-- - --i * ( i = -3 ) * i++ + ++i;
    printf("i = %d\n", i);
    return 0; 
}

在不同编译器中测试结果：非法表达式程序的结果。

值	编译器
—128	Tandy 6000 Xenix 3.2
—95	Think C 5.02(Macintosh)
—86	IBM PowerPC AIX 3.2.5
—85	Sun Sparc cc(K&C编译器)
—63	gcc，HP_UX 9.0，Power C 2.0.0
4	Sun Sparc acc(K&C编译器)
21	Turbo C/C++ 4.5
22	FreeBSD 2.1 R
30	Dec Alpha OSF1 2.0
36	Dec VAX/VMS
42	Microsoft C 5.1

在不同表达式有不同表现。

d. 表达式4

int fun()
{
     static int count = 1;
    //静态变量
     return ++count; 
}
int main()
{
     int answer;
     answer = fun() - fun() * fun();
     printf( "%d\n", answer);//输出多少？
     return 0; 
}

虽然在大多数的编译器上求得结果都是相同的。

但是从上述代码 answer = fun() - fun() * fun(); 中我们只能通过操作符的优先级得知：先算乘法，再算减法。

函数的调用先后顺序无法通过操作符的优先级确定。

e. 表达式5

#include <stdio.h>
int main()
{
    int i = 1;
    int ret = (++i) + (++i) + (++i);
    printf("%d\n", ret);
    printf("%d\n", i);
    return 0; 
}

Linux环境的结果：

在这里插入图片描述

VS2013环境的结果：

在这里插入图片描述

这段代码中的第一个 + 在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个 + 和第三个前置 ++ 的先后顺序。

总结：

我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。

操作符详解:操作符分类、算数操作符、移位操作符（进制转换）、位操作符（按位与、按位或、按位异或）、赋值操作符、单目操作符、关系操作符、逻辑操作符、条件操作符比较较大值、隐式类型转换etc。

操作符详解

文章目录

1. 操作符分类：

2. 算术操作符

3. 移位操作符

3.1 进制

3.1.1 整型的2进制表示：

3.2 左移操作符

3.2.1 正整数原理：

3.2.2 负整数原理：

3.3 右移操作符

4. 位操作符

4.1 按位与操作

4.2 按位或操作

4.3 按位异或操作

4.3.1 实现两个数的交换

异或操作支持交换律：

4.3.2 求一个整数存储在内存中的二进制中1的个数

5. 赋值操作符

6. 单目操作符

6.1 ！常见应用场景

6.2 &和*在指针里的应用

注意避免野指针问题（略）

6.3 sizeof 和 数组

a. sizeof

关于 sizeof 后括号是否可以省略 + sizeof 相关计算

sizeof（）内部的表达式是不会被计算的

关于截断

b. 数组

6.4 ~操作的常见应用场景

6.5 ++和–运算符

6.6 （类型）的应用场景

7. 关系操作符

8. 逻辑操作符

9. 条件操作符（三目操作符）

9.1 替换if…else

9.2 比较较大值

10. 逗号表达式

10.1 基本理解

10.2 条件判断语句中的应用（if、while）

11. 下标引用、函数调用和结构成员

11.1 [ ] 下标引用操作符

11.2 ( ) 函数调用操作符

11.3 访问一个结构的成员

12. 表达式求值

12.1 隐式类型转换

12.1.1 整型提升过程讲解

12.1.2 整体提升规则：

12.1.3 整型提升示例：

12.1.4 有表达式的整型提升：

12.2 算术转换

12.3 操作符的属性

12.3.1 操作符优先级：

13.3.2 一些问题表达式

a. 表达式1

b. 表达式2

c. 表达式3

d. 表达式4

e. 表达式5

6.3 sizeof 和数组