C语言的操作符讲解（下）~

6.下标访问[]、函数调用()

6.1 [] 下标引用操作符

操作数：一个数组名+一个索引值

举个例子：

#include 
int main(){

	int arr[10]={1,2,3,4,5,6,7,8,9,10};
	printf("%d\n",arr[9]);
	return 0;
}

在上面代码中，我们可以发现以下三条结论：、

1.int arr=[10];//创建数组

2.arr[9]=10;//实用下标引用操作符

3.[]的两个操作数是arr和9。

有些人可能对**[]的两个操作数为什么是arr和9呢**？

比方说：下面这串代码打印3+5的结果出来

printf("%d",3+5);

由上述代码可以看出，这里的3和5就是+号的两个操作数。

那同理，回到上面的[]的操作数为什么是arr和9呢？因为我们是通过arr数组名和下标9共同协助下标符号求出arr数组下标为9的元素出来，因此我们可以得出[]的两个操作数是arr和9。

6.2 函数调用操作符

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

比如，我们举个例子

#include 
void test1()
{
	printf("hehe\n");
}

int main()
{
    test1(); //这里的()就是作为函数调用操作符。
    return 0;
}

从这个代码中我们可以看出，test1后面的()就是作为函数调用操作符。

并且这个()函数调用操作符最少都会有一个操作数，也就是像上面代码中test();，括号里面是没有函数的参数，那么这个函数就只有一个操作数。

而如果说()操作符里面有参数，那么我们可以通过函数名+括号里面的参数。就能计算出该函数有多少个操作数了。

//sizeof 是不是函数呢？不是函数，是操作符
int main() {

  int a = 50;
  int b = sizeof a;
  printf("%d\n", b);

  return 0;
}

7. 操作符的属性：优先级、结合性

C语言的操作符有2个重要的属性：优先级、结合性，这两个属性决定类表达式求值的计算顺序。

7.1 优先级

优先级指的是，如果一个表达式包含多个操作符，哪个操作符应该先执行。各种运算符的优先级是不一样的。

比方说：

1 3+4*5;

上面示例中，表达式3+4x5里面既有加法运算符(+),又有乘法运算符（*）。由于乘法的优先级高于加法。所以会先计算4x5，而不是先计算3+4。

7.2 结合性

如果两个运算符优先级相同，优先级没办法确定先计算哪个了，这时候就要看结合性了，则根据运算符是左结合，还是右结合，决定执行顺序。大部分运算符是左结合(从左到右执行)，少数运算符是右结合(从右到左执行)，比如赋值运算符(=)。

1.5*6+2;

上面案例中，*和/的优先级相同，它们都是左结合运算符，所以从左到右执行，先计算5x6,再计算6/2。

运算符的优先级顺序有很多，下面是部分运算符的优先级顺序(按照优先级从高到低排列)，建议大概记住这些操作符的优先级就行，其他操作符在使用的时候查看下面的表格就可以了。

圆括号	（ () ）
自增运算符，自减运算符	(++),(–)
单目操作符	（ + 和- ）
乘法，除法	（ * ），(-)
加法，减法	(+),(-)
关系操作符	（ < 、> 等）

赋值操作符 (=)

下面这幅图是常用的操作符介绍

如果还想了解更多运算符和更多用法的话，大家可以点击下面链接看一下。

运算符参考文档：

8.表达式求值

8.1 整型提升

C语言中整型算术运算总是至少以缺省整类型的京都来进行的。

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

那么整型提升有什么意义呢？

接下来给大家讲一下~

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

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

通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中
可能有这种字节相加指令）。所以，表达式各种长度可能小于int长度的整型值，都必须转换为int或unsigned int,然后才能送入CPU去执行运算。

举个实例：

//实例1
char a,b,c;
...
a = b + c;

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

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

如何进行整体提升呢？

1.有符号的整数提升是按照变量的数据类型的符号来提升的

2，无符号整数提升，高位补0。

比方说：我们举个例子

如下图所示：

由于这个变量a的值为5，因为是char类型，那么变量a的二进制(补码)中只有8个比特位：

00000101

因为char为有符号的char,并且它的符号为是0，所以整型提升的时候，高位补充符号为，即为1。

提升之后的结果是：

00000000000000000000000000000101

反之，如果是求变量b的整型提升的值，那么结果就有所不同，因为变量b的值为129，而且是char类型，所以变量b的二进制(补码)中只有8个比特位。

10000001

细心的话，我们可以发现，这个是有符号的char,并且这个变量b的值符号位是1，因此我们是高位补充符号位，即为1

所以提升之后的结果是：

00000000000000000000000010000001

那么我们通过变量a和变量b整型提升后的二进制序列相加起来，然后余0进1，因为变量c为char类型，然后一个char类型等于8个bit,因此最多只能算8个二进制序列，所以我们要把它最后面的8个二进制序列给截断出来。

因此最终它的二进制序列结果是：

10000110

具体操作过程如下所示：

但是打印的结果真的就是这个二进制序列10000110的值吗？

细心的话，我们可以发现，这个变量c还是一个字符型操作数，我们要把它转换为普通整型int才能用%d的形式打印出来。所以我们要先对其进行整型提升，由于它的符号位是1，因此提升后的结果如下代码所示：

11111111111111111111111110000110

由于内存中存放的是补码的值，因此我们要把它按位取反+1，所以最终它的二进制序列为：

10000000000000000000000001111010

如果将这个二进制序列的值转换为%d的形式，它的值也就是-122。

那么它的转换流程以及这个运行用例如下图所示：

8.2 算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。

1.long double
2.double
3.float
4.unsigned long int
5.long int
6.unsigned int
7.int

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

举个例子：

我们看下面这串代码~

int main() {

    int a = 10;
    float f = 4.5f;

    printf("%f", a+f);
    return 0;
}

==我们可以看到变量a是int类型，而变量f是float类型，那么如果两个数相加起来，变量a要先转换为float的类型后才能进行运算。

运行结果如下图所示：

8.3 问题表达式解析

8.3.1 表达式1

1.//表达式的求值部分由操作符的优先级决定。
2.//表达式1
3.a*b + c*d + e*f

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

所以表达式的计算机顺序就可能是:

1.a*b
2.c*d
3.a*b + c*d
4.e*f
5.a*b + c*d + e*f

1.a*b
2.c*d
3.e*f
4.a*b + c*d
5.a*b + c*d + e*f

需要注意的是，我们不要想着这里的a,b,c,d,e,f就是个变量，我们需要把格局打开一些，如果a,b,c,d,e,f是个表达式，谁先算谁后算是不是有可能会受到影响？因此我们要避免写出这种代码。

因此我们可以得出下述结论

通过操作符的属性，无法确定这表达式的唯一计算路径！

那我们应该怎么修改这个代码？

我们可以这么写：

int x=a*b;
int y=c*d;
int z=x+y;
 e*f+z;

这样写的话，我们就可以很清晰地知道这个代码怎么叫唯一计算的。

8.3.2 表达式2

1  //表达式2
2 c+--c

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

举个例子：

我们在事先知道变量c的值为5，那么先算–的话，就是5+4=9。

具体操作如下图所示：

反之，如果我们事先没有准备那个5，先算–c,右边也就是4，那么左边那个操作数用当前算好的值，那么表达式最终结果为：4+4=8。

具体看下图：

也就是说，左边的变量c和右边的变量c都是有联系的，因为它们都是相同的变量。那么右边的变量c有可能会影响左边变量c的，所以这个变量c是在–之前准备还是在–之后准备，它的结果是不是截然不同呢？

8.3.3 表达式3

更有甚者，我们有时会碰到这样的代码：

我们不妨来看一下

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

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

这个代码时由**<>这本书的作者**用各种各样编译器测试的代码，但是我们发现，每个编译器的代码测试的结果都不相同，像这种代码，我们是一定要避免写的，如果在公司企业写出这钟类型的代码，很可能会被开除！

8.3.4 表达式4

接下来，我们再看一下下面这几行代码~

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

这里需要注意的是：与前面代码不一样的是，这里有个static来修饰这个局部变量，我们都知道static是修饰局部变量的 并且出了那个作用域是不会销毁函数的，因此每次它调用那个函数fun(),那个变量count每次都会递增1，

比如第一次调用的话，count的值为1，返回的值为2

第二次调用的话，count的值为2，返回的值为3

第三次调用的话，count的值为3，返回的值为4

因此我们可以得出这样的结论：调用函数的次数不同，它每一次的返回值也会不同。

然后我们再看下面main函数的代码，**虽然在大多数的编译器上求得结果都是相同的。**但是上述代码

    answer = fun() - fun() * fun();

我们只能通过操作符的优先级得知：先算乘法，再算减法。

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

我们不妨来看一下下面这样代码的运行结果：

这个表达式也是从最左边调用的函数fun()逐步向右执行，然后因为static修饰局部变量count,所以每次调用那个fun()函数，那个变量count每次都会自增，那么它的计算结果也就是2-3*4=-10。

而如果说，我们如果想让它先计算那两个相乘的fun函数，我们可以先定义一个变量a,然后先让a=fun()*fun(),然后再用第三次调用的fun函数-a，那就能求出它的值为-2。

下面是这个代码执行和运行图，大家可以看看~

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

8.3.5 表达式5

我们再来看下面这几行代码：

//表达式5
#include 
int main()
{
    int i = 1;
    int ret = (++i) + (++i) + (++i);
    printf("%d\n", ret);
    printf("%d\n", i);
    return 0;
}

然后我们试着使用XSHELL远程服务器编译器执行它的结果：

VS2022运行结果：

看看同样的代码产生了不同的结果，这是为什么？

简单看一下汇编代码，就可以分析清楚。

如下图所示：

我们先把1赋给i,然后再把1赋给[edp-8]，另外，我们通过调试窗口可以发现i的地址和[edp-8]的地址是一模一样的。

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

8.4 总结

即使有了操作符的优先级和结核性，我们写出的表达式依然会有可能不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在风险的，因此大家建议不要写出特别复杂的表达式。

---

---

好啦！今天的分享就到次结束了，如果觉得博主讲得不错的话，欢迎大家一键三连支持一下！

谢谢大家啦！！！