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

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

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

前言

操作符的分类：

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

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

七、关系操作符

大于操作符：   >

小于于操作符：  <

大于等于操作符： >=

小于等于操作符： >=

相等操作符：   ==

不相等操作符：  !=

关系表达式通常返回 0 或 1，表示真假。

关系表达式通常用于 i f if if 或 w h i l e while while 结构

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

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

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

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

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

i < j < k;

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

（i < j） < k;

i i i 和 j j j 的比较结果为真返回 1 ，为假返回 0，1 或者 0 与 k k k 比较

应该使用下面这种写法：

i < j && j < k;

八、逻辑操作符

&&  与运算符，就是并且 的意思（两侧表达式都为真，即为真，否则为假）

| |  或运算符，就是或者 的意思（两侧至少有一个表达式为真，则为真，否则为假）

！  逻辑取反操作符（改变当表达式的真假）

8.1、& 与运算符

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

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

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

8.2、 | 或运算符

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

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

九、条件操作符

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

e x p 1 exp1 exp1  ?  e x p 2 exp2 exp2  :   e x p 3 exp3 exp3

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

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

#include<stdio.h>

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

十、逗号表达式

e x p 1 ， e x p 2 ， e x p 3 ， ... e x p N exp1，exp2，exp3，...expN exp1，exp2，exp3，...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 a a 赋值为 12
• a ：不产生任何效果
• b = a + 1：将 b b b 赋值为 13

逗号表达式的结果为最后一个表达式的结果， c c 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，但是前面表达式的运算结果可能会影响最后一个表达式。

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

代码三：

a = get_val();
count_val(a);

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

这段代码的逻辑是：先对 a a a 进行处理，如果 a > 0 a>0 a>0 ，进行业务处理，处理完后，再对 a a a 进行处理，如此循环。
  不难发现，这段代码有点冗余，怎么办呢 ？这时，就可以巧用逗号表达式了

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

怎么样，是不是很巧妙呢。

这里可能有小伙伴会说可以用 d o − w h i l e do-while do−while 循环，但是 d o − w h i l e 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）直接访问

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

#include<stdio.h>

struct Point
{
	int x;
	int y;
}p = { 10,20 };

int main()
{
	printf("x: %d y: %d", p.x, p.y);
	return 0;
}

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

（2）间接访问

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

#include<stdio.h>

struct 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）的操作数的字节长度一般就是 i n t int int 的字节长度，同时也是CPU的通用寄存器的长度。

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

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

下面我们看一段代码：

#include<stdio.h>

int main()
{
	char a = 3;
	char b = 127;

	char c = a + b;
	printf("%d\n", c);
}

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

• 变量 a a a 中，存的是整数 3 ，在内存中存的是32位二进制序列，即：00000000 00000000 00000000 00000011。
• 而变量 a a a 是 c h a r char char 类型，只能存放 1 个字节，即：00000011
• 同理，变量 b b b 中存放的是：01111111
• 在执行：char c = a + b;语句时，不是让他们直接相加，而是先进行整形提升，再相加。即：
      00000000 00000000 00000000 00000011
     + 00000000 00000000 00000000 01111111
     = 00000000 00000000 00000000 10000010
• 因为变量 c c c 是 c h a r char char 类型，只有一个字节，所以 c c c 中存放的是：10000010
• printf("%d\n", c);中，我们知道，%d 打印的是有符号整数，所以在打印的时候也会发生整型提升，由于 c h a r char char 类型在大部分编译器上相当于 u n s i g n e d unsigned unsigned  c h a r char 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

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

下面我们来看一道题：

//求下面代码的输出结果

#include<stdio.h>
int main()
{
    int i = 0;
    i--;
    if (i > sizeof(i))
    {
        printf(">\n");
    }
    else
    {
        printf("<\n");
    }
    return 0;
}

运算结果：

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

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

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