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

[ ]下标引用操作符

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

int arr[10];//创建数组
arr[9] = 10;//实⽤下标引⽤操作符。
[ ]的两个操作数是arr和9
3+5     3和5是加号的两个操作数

函数调用操作符

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

#include <stdio.h>
void test1()
{
printf("hehe\n");
}
void test2(const char *str)
{
printf("%s\n", str);
}
int main()
{
test1(); //这⾥的()就是作为函数调⽤操作符。
test2("hello bit.");//这⾥的()就是函数调⽤操作符。
return 0;
}

注意：函数的操作数最小只有一个即只有一个函数名，不传参数（void）
这里随便提一下sizeof不是函数，是操作符

#include<stdio.h>
int main()
{
int a=10;
int n=sizeof(a)和int n=sizeof a其实都一样
printf（"%d\n",n）;
return 0;
}

我们可以看到int n=sizeof(a)和int n=sizeof a的差别就是一个（），而函数需要（），因此sizeof不是函数而是操作符

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

C语言的操作符有两个重要的属性，优先级，结合性，这两个属性决定了表达式求值的计算顺序（可近似成数学的运算但仍有一定的区别）

优先级

在运算时如果一个表达式包含多个运算符，哪个运算符应该优先执行？
为了解决这问题，就规定了各运算符的优先级

 3 + 4 * 5;

上面示例中，表达式 3 + 4 * 5 里面既有加法运算符（ + ），又有乘法运算符（ * ）。由于乘法的优先级高于加法，所以会先计算 4 * 5 ，而不是先计算 3 + 4 。（这里其实就是数学的运算规则）

结合性

当两个运算符的优先级都相同时，也就是运算符相同时，我们无法根据优先级进行判断先从哪计算，于是这种情况就需要用到结合性了，但结合性是分情况的，有的会左结合（从左向右计算），有的会右结合（从右向左计算），但大多数都是从左向右计算

5 * 6 / 2;

上面示例中， * 和 / 的优先级相同，它们都是左结合运算符，所以从左到右执行，先计算 5 * 6 ，再计算 6 / 2 。运算符的优先级顺序很多，下面是部分运算符的优先级顺序（按照优先级从高到低排列），建议大概记住这些操作符的优先级就行
• 圆括号（ () ）
• 自增运算符（ ++ ），自减运算符（ – ）
• ⼀元运算符（ + 和 - ）
• 乘法（ * ），除法（ / ）
• 加法（ + ），减法（ - ）
• 关系运算符（ < 、 > 等）
• 赋值运算符（ = ）
由于圆括号的优先级最高，可以使用它改变其他运算符的优先级

操作符的优先级参考链接

表达式求值

整型提升

C语言中整型算术运算总是至少以缺省整型类型的精度来进行的（即储存数据类型小于整型储存的32比特位时就使小于32比特位的数据类型整型提升）
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升

整型提升的意义

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度⼀般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。（因此反正都是要转换的整型操作数的标准长度，为就把增加的字节长度用上使精度更准）
通用CPU是难以直接实现两个8比特字节直接相加运算（虽然机器指令中
可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算

//实例1
char a,b,c;
char a=5;
//00000000 00000000 00000000 00000101
//00000101(截断后存储到a中）
char b=127;
//00000000 00000000 00000000 01111111
01111111（截断后存储到b中）
char a = b + c;
//00000000 00000000 00000000 00000101  a
//00000000 00000000 00000000 01111111  b
//00000000 00000000 00000000 10000100
//10000100（截断后存储到c中）
printf（“%d”,c）
//这里还是要整型提升
//11111111 11111111 11111111 10000100 补码
//10000000 00000000 00000000 01111011 反码
//10000000 00000000 00000000 01111010 原码
//%d是按照10进制的形式打印有符合的整数
/*可能会有人对这有疑惑11111111 11111111 11111111 10000100 补码
为什么左边全是1，其实是因为在整形提升时最高位补符号位*/
b和c的值被提升为普通整型，然后再执⾏加法运算。
加法运算完成之后，结果将被截断，然后再存储于a中

如何进行整体提升

1. 有符号整数提升是按照变量的数据类型的符号位来提升的
2. 无符号整数提升，高位补0

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

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

算术转换

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

1.long double
2.double
3.float
4.unsigned long int
5.long int
6.unsigned int
7.int
//如果某个操作数的类型在上⾯这个列表中排名靠后，那么⾸先要转换为另外⼀个操作数的类型后执⾏
运算。
//比如int和double，因为int排在double后面，所以要将int转换为double类型再执行运算

问题表达式解析

以下的表达式和数学的计算方法有冲突，所以要特别注意

表达式1

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

许多人会同时算ab,cd,ef因为的优先级比+更高，
但是优先级并不能决定第三个* 比第一个 + 早执行，因为它只能觉定和它相邻的算数运算符
所以表达式的计算机顺序就可能是：

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

但也有可能是

a*b
c*d
e*f
a*b + c*d
a*b + c*d + e*f

表达式2

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

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

intc=1;
c+--c

如果第一个c为1那么c+ --c=1+0=1
而如果第一个c是在–c后再赋值那么c+ --c=0+0=0
所以代码别这么写，否则最后的结果自己都搞不清楚是怎么来的

表达式3

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

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

表达式4

#include <sdtio.h>
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(); 中我们只能通过操作符的优先级得知：先
算乘法，再算减法，但函数的调用先后顺序无法通过操作符的优先级确定

表达式5

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

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

总结

即使有了操作符的优先级和结合性，我们写出的表达式依然有可能不能通过操作符的属性确定唯⼀的计算路径，那这个表达式就是存在潜在风险的，建议不要写花里胡哨的表达式，否则自己都会搞蒙