【C语言】——详解操作符（下）

【C语言】——详解操作符（下）

• • 前言
  • 七、关系操作符
  • 八、逻辑操作符
  • • 8.1、& 与运算符
    • 8.2、 | 或运算符
  • 九、条件操作符
  • 十、逗号表达式
  • 十一、下标引用与函数调用操作符
  • • 11.1、[ ] 下标引用操作符
    • 11.2、( ) 函数调用操作符
  • 十二、 结构成员操作符
  • • 12.1、结构体
    • 12.2、结构体成员访问操作符
  • 十三、操作符的属性：优先级、结合性
  • • 13.1、优先级
    • 13.2、结合性
  • 十四、表达式求值
  • • 14.1、整型提升
    • 14.2、算术转换

前言

  
 操作符的分类：

• 算数操作符：+ 、 - 、* 、/ 、%
• 位移操作符：<>
• 位操作符： & 、 | 、^ 、 ~
• 赋值操作符：= 、 += 、 -= 、 *= 、 /= 、 %= 、 <>= 、 &= 、 |= 、 ^=
• 单目操作符： ！ 、 ++ 、 -- 、 & 、 * 、 + 、 - 、 ~ 、 sizeof 、（类型）
• 关系操作符：> 、 >= 、 < 、 <= 、 == 、!=
• 逻辑操作符：&& 、 ||、！
• 条件操作符：？ 、:
• 逗号表达式：，
• 下标引用： [ ]
• 函数调用： ( )
• 结构成员访问： . 、->

  上一章（【C语言】——详解操作符（上））中，我给大家详细讲解了前五种操作符，接下来，让我们继续把剩下的操作符学完吧。

七、关系操作符

大于操作符：   >
小于于操作符：  <
大于等于操作符： >=
小于等于操作符： >=
相等操作符：   ==
不相等操作符：  !=

  关系表达式通常返回 0 或 1，表示真假。
 
 关系表达式通常用于 $if$ 或 $while$ 结构

if(x == 3){printf("x is 3.\n");}

  注意：相等操作符 == 与赋值操作符 = 是两个不一样的运算符，不要混淆。有时可能不小心写错，但程序是不会报错的，很容易出现意料之外的结果。
 

  为了防止这种错误，我们可以将变量写在等号的右边，这样，如果把 == 误写成 = ，编译器就会报错

if(3 == x )...if(3 = x)//报错

  同时，需要注意，多个运算符不宜连用

i < j < k;

  上面示例中，连续使用俩个 < ，是合法表达式，程序不会报错。但往往会与你想要实现的结果大相径庭，即不是保证变量 $j$ 在 $i$ 和 $k$ 之间。因为关系运算符时从左往右算，所以实际执行的是下面的表达式：

（i < j） < k;

  $i$ 和 $j$ 的比较结果为真返回 1 ，为假返回 0，1 或者 0 与 $k$ 比较
 
 应该使用下面这种写法：

i < j && j < k;

八、逻辑操作符

&&  与运算符，就是并且的意思（两侧表达式都为真，即为真，否则为假）
 
| |  或运算符，就是或者的意思（两侧至少有一个表达式为真，则为真，否则为假）
 
！  逻辑取反操作符（改变当表达式的真假）

8.1、& 与运算符

  && 就是与运算符，也是并且的意思。&& 是一个双目操作符，使用方式是 $a$ && $b$ ，&& 两边表达式都是真的时候，整个表达式为真，只要有一个为假，则整个表达式为假。
 

int month = 0;scanf("%d", &month);if(month >= 3 && month <= 5){printf("春季\n");}

  这里表达式的意思是 $month$ 既要大于等于3，又要小于等于5，必须同时满足。
 

8.2、 | 或运算符

  
 | |就是或运算符，也就是或者的意思。| |也是一个双目操作符，使用方法是a || b， | | 两边的表达式只要有一个是真，整个表达式就是真，两边都为假的时候，才为假。

int month = 0;scanf("%d", &month);if(month == 12 || month == 1 || month == 2){printf("冬季\n");}

九、条件操作符

 
 条件操作符也叫三目操作符，需要接受三个操作数，形式如下：

$exp1$” />$exp2$  :$exp3$

  
 条件操作符的计算逻辑是：如果 $exp1$ 为真， $exp2$ 计算，如果 $exp1$ 为假，$exp3$ 计算，计算的结果是整个表达式的结果。

  
例：使用条件表达式实现两个数中的较大值

#includeint main(){int a = 0;int b = 0;scanf("%d %d", &a, &b);int m = a > b ? a : b;printf("%d\n", m);return 0;}

十、逗号表达式

$exp1，exp2，exp3，\dots expN$

  逗号表达式，就是用逗号隔开的多个表达式
 
 逗号表达式，从左到右一次执行，整个表达式的结果是最后一个表达式的结果。
 
 
代码一：

//c是多少？int main(){int a = 1;int b = 2;int c = (a > b, a = b + 10, a, b = a + 1);return 0;}

上述逗号表达式：

• a > b ：结果为 0 ，但是不重要，因为并没有对任意变量赋值，不产生结果
• a = b + 10 ：将 $a$ 赋值为 12
• a ：不产生任何效果
• b = a + 1：将 $b$ 赋值为 13

  
逗号表达式的结果为最后一个表达式的结果，$c$ 结果为13

  
代码二：

int main(){int a = 0, b = 0, c = 0, d = 0;if (a = b + 1; d = c / 2, d > 0){}return 0;}

  前面两个表达式正常算，但真正起到判断作用的还是d > 0，但是前面表达式的运算结果可能会影响最后一个表达式。

  没想到吧，$if$ 语句还能这么写
 

代码三：

a = get_val();count_val(a);while (a > 0){//业务处理//……a = get_val();count_val(a);}

  这段代码的逻辑是：先对 $a$ 进行处理，如果 $a>0$ ，进行业务处理，处理完后，再对 $a$ 进行处理，如此循环。

  不难发现，这段代码有点冗余，怎么办呢 ？这时，就可以巧用逗号表达式了

while (a = get_val, count_val(a), a > 0){//业务处理}

  怎么样，是不是很巧妙呢。
 
 这里可能有小伙伴会说可以用 $do-while$ 循环，但是 $do-while$ 循环是一上来直接进行循环，并没有开始的判断部分。
 
 

十一、下标引用与函数调用操作符

下标引用操作符：  [ ]
函数调用操作符： ( )

  怎么样，没想到吧，原来他两也是操作符
 

11.1、[ ] 下标引用操作符

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

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

11.2、( ) 函数调用操作符

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

int Add(int x, int y){return x + y;}int main(){printf("hehe\n");//( )函数调用操作符int ret = Add(2, 3);//( )函数调用操作符return 0;}

  函数调用操作符至少一个操作数，操作数无上限
   
 

十二、 结构成员操作符

12.1、结构体

  C语言中，已经提供了内置类型，如：char、short、int、long、float、double等，但是仅仅只靠这些内置类型还是不够的。
 
 假设我们想描述一个想学生，描述一本书，这时，单一的内置类型肯定是不行的。描述一个学生需要名字、年龄、学号、身高、体重等；描述一本书需要作者、出版社、定价等。
 
 C语言为了解决这个问题，增加了结构体这种自定义的数据类型，让我们可以自己创造合适的类型

  结构体是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量，如：标量、数组、指针、甚至是其他结构体。

  
（1）结构体的声明

struct tag//结构体标签{member-list;//成员列表}variable-list;//结构体变量

例如：描述一个学生

struct Stu{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号}；//分号不能丢

  
（2）结构体的定义和初始化

//变量的定义struct Stu{char name[15];int age;}p1, p2, p3; //声明类型的同时定义多个变量struct Stu p4;//定义结构体变量//这些定义的变量都是全局变量//初始化struct Stu p5 = { "Zhangsan",20 };//指定顺序初始化struct Stu p6 = { .age = 18,.name = "lisi" };

12.2、结构体成员访问操作符

  
（1）直接访问

  结构体成员的直接访问都是通过点操作符$（.）$访问的。点操作符接受两个操作数。

#includestruct Point{int x;int y;}p = { 10,20 };int main(){printf("x: %d y: %d", p.x, p.y);return 0;}

使用方式：结构体变量 $.$ 成员名

  
（2）间接访问
 有时我们得到的不是一个结构体变量，而是得到了一个指向结构体的指针。如下所示：

#includestruct Point{int x;int y;};int main(){struct Point p = { 1,2 };struct Point* ptr = &p;ptr->x = 10;ptr->y = 20;printf("x = %d y = %d\n", ptr->x, ptr->y);return 0;}

使用方式：结构体指针 -> 成员名
   
 

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

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

13.1、优先级

  优先级是指：一个表达式中有多个操作符，根据每个操作符的优先级大小判断哪个操作符先执行。
例如：

3 + 4 * 5；

  上述表达式中，既有加法运算符，又有乘法运算符。由于乘法运算符的优先级更高，所以会先计算 4 * 5。
 

13.2、结合性

  当两个操作符的优先级相同，该怎么办呢？这时，就要用结合性来判断了。根据运算符是左结合，还是右结合，决定执行顺序。大部分运算符是左结合（即从左到右执行），当然，也有少部分运算符是右结合（即从右到左执行），比如赋值运算符（=）

5 * 6 / 2;

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

表格来源：cppreference.com
 
 

十四、表达式求值

14.1、整型提升

  
 C语言中,整形算术运算总是至少以整形类型的精度来进行的。
 为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型转换。
 
 如何进行整型提升呢？
 

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

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

  
下面我们看一段代码：

#includeint main(){char a = 3;char b = 127;char c = a + b;printf("%d\n", c);}

  上述代码的结果是多少呢？会是 130 吗？别急，我们一步步来看。
 

• 变量 $a$ 中，存的是整数 3 ，在内存中存的是32位二进制序列，即：00000000 00000000 00000000 00000011。
• 而变量 $a$ 是 $char$ 类型，只能存放 1 个字节，即：00000011
• 同理，变量 $b$ 中存放的是：01111111
• 在执行：char c = a + b;语句时，不是让他们直接相加，而是先进行整形提升，再相加。即：
   00000000 00000000 00000000 00000011
    + 00000000 00000000 00000000 01111111
    = 00000000 00000000 00000000 10000010
• 因为变量 $c$ 是 $char$ 类型，只有一个字节，所以 $c$ 中存放的是：10000010
• printf("%d\n", c);中，我们知道，%d 打印的是有符号整数，所以在打印的时候也会发生整型提升，由于 $char$ 类型在大部分编译器上相当于 $unsigned$ $char$ 类型，因此整型提升按符号位来提升，即：11111111 11111111 11111111 10000010。
• 而上述整型提升所得到的是补码（在内存中，所有的存储和运算都是补码的形式，只有打印时，是按原码打印），由补码得原码：10000000 00000000 00000000 01111110  —— –126

运行结果：

 结果是 –126，你们做对了吗。
 

14.2、算术转换

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

• long double
• double
• float
• unsigned long int
• long int
• unsigned int
• int

  如果某个操作数的类型在上面这个列表中排名靠后，那么首先要转化为另外一个操作数的类型后执行运算。
 
 下面我们来看一道题：

//求下面代码的输出结果#includeint main(){int i = 0;i--;if (i > sizeof(i)){printf(">\n");}else{printf("<\n");}return 0;}

运算结果：

 为什么呢？ –1 还能比 4 大？别急，我们一起来看看
 

• 首先，整型变量 $i$ 初始化为 0 ，后自减得 –1
• 在if (i > sizeof(i))语句中，$i$ 与 $sizeof(i)$ 比较，因为 $sizeof$ 至少也是 $unsignedint$ ,比 $int$ 排名靠前，$i$ 发生整型转换
• –1 的补码是：11111111 11111111 11111111 11111111，整型转换后成了一个很大的数： 232− 12^{32}-1232−1
• 这样一比较，答案即是：> 。

  
 
 
 好啦，本期关于C语言操作符就介绍到这里啦，希望本期博客能对你有所帮助，同时，如果有错误的地方请多多指正，让我们在C语言的学习路上一起进步！