🌞 “等春风得意，等时间嘉许！” 接下来，我们把操作符没学完的继续学完！

6.2sizeof和数组

📖我们来看一下下面这段代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
void test1(int arr[])//相当于int *arr
//传的是数组首元素的地址
{printf("%d\n", sizeof(arr));//指针的大小在32位的编译器里是4个字节，在64位的编译器里是8个字节
}
void test2(char ch[])
{printf("%d\n", sizeof(ch));
}
int main()
{int arr[10] = { 0 };char ch[10] = { 0 };printf("%d\n", sizeof(arr));//数组有10个整型元素，所以结果是40printf("%d\n", sizeof(ch));//数组有10个字符型元素，结果是10test1(arr);test2(ch);return 0;
}

7.关系操作符

关系操作符：> >= < <= !=（用于测试不相等） ==（用于测试相等）

注：不要把==和=混起来❗
✅==用于测试相等，=用于赋值。

8.逻辑操作符

📖逻辑操作符：&&（逻辑与操作符） ||（逻辑或操作符）

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{int month = 0;scanf("%d",&month);if (month >= 3 && month <= 5){printf("春季\n");}if (month == 12 || month == 1 || month == 2){printf("冬季\n");}return 0;
}

🔎这里我们来看一道题：

#include <stdio.h>
int main()
{int i = 0, a = 0, b = 2, c = 3, d = 4;i = a++ && ++b && d++;//a++先得到0，对于&&操作符，前面为假，后面就不会计算了printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);//1 2 3 4printf("i = %d\n", i);return 0;
}

📖这里，如果我们将a的值变为1，那么结果是什么呢？

#include <stdio.h>
int main()
{int i = 0, a = 1, b = 2, c = 3, d = 4;i = a++ && ++b && d++;//i = 1&&3&&4=1printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);printf("i = %d\n", i);return 0;
}

💻同样的，如果我们这里将&&改为||，结果又是怎么样的呢？

#include <stdio.h>
int main()
{int i = 0, a = 1, b = 2, c = 3, d = 4;i = a++ || ++b || d++;//a++先得到结果1，表达式已经为真，后面不计算，b和d的值不变printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);printf("i = %d\n", i);return 0;
}

9.条件操作符

📖条件操作符：表达式1 ?表达式2:表达式3
✅唯一 一个三目操作符。
🧩表达式1为真，表达式2的结果为整个表达式的结果，表达式3不算.
🧩表达式1为假，表达式3的结果为整个表达式的结果，表达式2不算。

📝如果我们这里需要计算出两个数的最大值，按照前面所学的，我们可能会这样写：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{int a = 0;int b = 0;int m = 0;scanf("%d%d", &a, &b);if (a > b)m = a;elsem = b;printf("%d\n", m);return 0;
}

📖但是，这里如果我们用上条件操作符就会省很多事❗

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{int a = 0;int b = 0;scanf("%d%d", &a, &b);printf("%d\n", a > b ? a : b);return 0;
}

10.逗号表达式

📖逗号表达式：表达式1,表达式2,表达式3......
✅逗号表达式会从左往右依次执行，整个表达式的结果是最后一个表达式的结果。

📝那我们一起看看下面这段代码的运行结果是怎么样的呢？

#include <stdio.h>
int main()
{int a = 1;int b = 2;int c = (a > b, a = b + 5, a, b = a + 10);//        0         7      7       17printf("%d\n", c);return 0;
}

🔎示例：

#include <stdio.h>
int main()
{int a = 0;while (a > 0){a = get_val();count_val(a);}//上述while循环可以改写为以下的代码：/*while (a = get_val(), count_val(a), a>0){}*/return 0;
}

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

📖下标引用操作符[]
💻操作数为：一个数组名+一个索引值

#include <stdio.h>
int main()
{int arr[] = { 1,2,3,4,5,6,7,8,9,10 };//诸如0 1 2 3 4 5 6 7 8 9 称为索引值printf("%d\n", arr[2]);//[]-下标引用操作符return 0;
}

📖函数调用操作符()
💻接受一个或多个操作数：第一个操作数是函数名，剩余的操作数是传递给函数的参数。

#include <stdio.h>
int add(int x, int y)
{return x + y;
}
int main()
{printf("%d", add(3, 4));//()函数调用操作符，最少有一个操作数为函数名return 0;
}

📖访问一个结构体成员
💻结构体.成员名 结构体指针->成员名

#include <stdio.h>
struct Book
{char name[20];int price;
};
int main()
{struct Book b = { "明解C语言",50 };printf("%s %d\n", b.name, b.price);return 0;
}

📖以下三种写法，得到的结果相同：

#include <stdio.h>
struct Book
{char name[20];int price;
};
void Print(struct Book* pb)
{printf("%s %d\n", (*pb).name, (*pb).price);printf("%s %d\n", pb->name, pb->price);
}
int main()
{struct Book b = { "明解C语言",50 };printf("%s %d\n", b.name, b.price);Print(&b);return 0;
}

12.表达式求值

📖表达式求值的顺序一部分是由操作符的优先级和结合性来决定的。同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。

12.1隐式类型转换

C的整型算术运算总是至少以缺省整形类型的精度来进行。为了获取这个精度，表达式中的字符和短整型操作数之间被转换为普通整型，这样的类型转换为整型提升。
📖整型提升是按照变量的数据类型的符号位来提升的。

#include <stdio.h>
int main()
{char a = 5;//00000101//整型提升：00000000000000000000000000000101char b = 126;//01111110//整型提升：00000000000000000000000001111110char c = a + b;//c:         00000000000000000000000010000011//10000011//c整型提升：11111111111111111111111110000011//反码：     11111111111111111111111110000010//原码：     10000000000000000000000001111101//-（1+4+8+16+32+64）=-125printf("%d\n", c);return 0;
}

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

#include <stdio.h>
int main()
{char c = 1;printf("%d\n", sizeof(c));printf("%d\n", sizeof(+c));printf("%d\n", sizeof(-c));
//c只要参加表达式运算，就会发生整型提升return 0;
}

12.2算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。
long double、double、float、unsigned long int、long int、unsigned int、int
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运 算。 ❗警告： 但是算术转换要合理，要不然会有一些潜在的问题。

12.3 操作符的属性

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

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

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

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

📖对于下面的这个表达式，表达式的计算顺序就不一定了！

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

❌同样的，对于下面的这个表达式：

c + --c;

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

📖📖📖我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的，我们在写程序的时候，要避免写出这样的代码💯

好啦，关于操作符的知识点到这里就结束啦，后期会继续更新C语言的相关知识，欢迎大家持续关注、点赞和评论！❤️❤️❤️