【C语言】操作符（下）： -- 条件操作符 --逗号表达式 -- 下标引用操作符 --表达式求值

小白在努力jy

已于 2023-03-27 11:20:26 修改

阅读量336

点赞数 13

分类专栏： C语言初阶文章标签： c++ c语言算法

于 2023-03-19 21:14:52 首次发布

本文链接：https://blog.csdn.net/Ljy_cx_21_4_3/article/details/129656508

版权

C语言初阶专栏收录该内容

16 篇文章 1 订阅

订阅专栏

1、条件操作符

exp1 ？ exp2 ：exp3

含义：exp1是否为真，为真exp2为整个表达式结果，为假exp3为整个表达式结果。

我们看一段代码：

#include <stdio.h>
int main()
{
    int a = 3;
    int b = 0;
    if (a > 5)
        printf("%d\n", a);
    else
        printf("%d\n", b);
    return 0;
}

效果展示：

我们将这段代码改为条件表达式语句：

上面的 if - else 语句的意思是：如果 a > 5，打印 a，否则打印 b。

我们根据这句话来改：

#include <stdio.h>
int main()
{
    int a = 3;
    int b = 0;
    int c = (a > 5) ? a : b;
    printf("%d\n", c);
    return 0;
}

效果展示：

2、逗号表达式

exp1，exp2，exp3，…expN

逗号表达式就是用逗号隔开的多个表达式。

逗号表达式从左到右依次执行。整个表达式的结果是最后一个表达式的结果。

Q：看一段代码，给出答案

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

我们来分析一下：

按照逗号表达式的执行流程来分析，c 先执行 a > b, 不管是否大于它都会往后走，经过 a = b + 10，得出 a = 12，再经过 a，a 还是 12，在经过 b = a + 1，得出 b = 13，执行完后赋给 c，这时 c = 13。

我们看展示效果：

这就验证了：逗号表达式从左到右依次执行。整个表达式的结果是最后一个表达式的结果。

再来看一段代码：

if (a = b + 1, c = a / 2, d > 0)

这个 if 语句的判断内容是逗号表达式，真正的判断语句是最后一个表达式，只有d > 0 时才进入 if 语句，但是还是从左到右依次执行，因为有可能前面的式子影响最后一个式子。

逗号表达式的灵活使用：

我们看一段代码，并且对它进行改写

#include <stdio.h>
int main()
{
	int a = 3 + 5;
	int a = a + 1;
	while (a > 0)
	{
		//业务处理
		;
	}
	return 0;
}

分析：

这段代码从进入main函数开始就在对 a 进行操作，a 的值一直在改变，并且在经过两次处理后作为 while 循环的条件判断句。那我们是不是就可以使用逗号表达式对它进行改写：

#include <stdio.h>
int main()
{
	int a = 0;
	while ((a=3+5), (a=a+1), a > 0)
	{
		//业务处理
	}
	return 0;
}

3、下标引用操作符

[ ] -- 下标引用操作符

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

我们以代码来深入了解

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	//	这里[ ]不是下标引用操作符，这是语法规定。
	printf("%d\n", arr[2]);
	//            这个[ ]就是下标引用操作符。arr与2是操作数。
	return 0;
}

分析：

我们这里要打印3，就找arr[2]，将它打印出来。这里的 [ ] 就是下表引用操作符，arr 与 2 就是操作数。而初始化的 [ ] 不是下标引用操作符，是语法规定。

4、函数调用操作符

（）-- 函数调用操作符

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

我们还是以代码来深入了解

#include <stdio.h>
#include <string.h>
int main()
{
	int len = strlen("abc");
	//			 这里()就是函数调用操作符，里面的形参"abc"就是操作数
	printf("%d\n", len);
	return 0;
}

分析：

我们这里调用了库函数 strlen ，strlen后面的( )就是函数调用操作符，里面的形参 "abc" 以及函数名 strlen 都是操作数。自定义函数在调用的时候也是这样的。

5、结构成员

访问一个结构体成员（有两种形式）

. 结构体变量 . 成员名

-> 结构体指针 -> 成员名

我们以代码深入了解

#include <stdio.h>
struct S
{
	int num;
	char ch;
};
int main()
{
	struct S s = { 100, 'L' };//结构体初始化时用{}。
	//找结构体中的成员
	printf("%d\n", s.num);
	printf("%c\n", s.ch);

	return 0;
}

效果展示：

这里我们使用 . 来访问。

如果我们是以指针形式访问的话就得使用 -> 来访问。

如下：

#include <stdio.h>
struct S
{
	int num;
	char ch;
};
void test(struct S* ps)
{
	printf("%d\n", ps->num);
	printf("%c\n", ps->ch);
}
int main()
{
	struct S s = { 100, 'L' };//结构体初始化时用{}。
	test(&s);

	return 0;
}

效果展示：

传的是地址因此我们可以通过地址找到 s ，因此也可以使用 . 来访问。

//我们将下面两句进行改写
printf("%d\n", ps->num);
printf("%c\n", ps->ch);
//改写为：
printf("%d\n", (*ps).num);
printf("%c\n", (*ps).ch);

6、表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。

同样，有些表达式的操作数在求值的过程中可能要转换为其他类型。

6.1 隐士类型转换

c 的整形算术运算总是至少以缺省整形类型的精度来进行的。

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

Q：如何进行整形提升的呢？

char c1 = -1;
char c2 = 1;

A：规则：整型提升是按照变量的数据类型的符号位来提升的。无符号整形提升，高位补 0 。

变量 c1 二进制补码的表示只有 8 个比特位：11111111

因为 char 是有符号的 char，所以整形提升的时候高位补充符号位，即为 1 。

整形提升后的结果：11111111 11111111 11111111 11111111

变量 c2 二进制补码的表示也只有 8 个比特位：00000001

因为 char 是有符号的 char，所以整形提升的时候高位补充符号位，即为 0 。

整形提升后的结果：00000000 00000000 00000000 00000001

我们来看一段加法代码：

#include <stdio.h>
int main()
{
	char a = 3;
	char b = 127;
	char c = a + b;

	printf("%d\n", c);
	return 0;
}

分析：

a 的二进制补码：00000000 00000000 00000000 00000011

因为是 char 类型，一个字节，截断：00000011

b 的二进制补码：00000000 00000000 00000000 01111111

因为是 char 类型，一个字节，截断：01111111

a + b 需要整型提升，因为是有符号数，且符号位为 0，因此都用 0 补充

a：00000000 00000000 00000000 00000011

b：00000000 00000000 00000000 01111111

c：00000000 00000000 00000000 10000010

对 c 进行截断：10000010

打印是要整型提升：

c 的补码二进制：11111111 11111111 11111111 10000010

c 的反码二进制：10000000 00000000 00000000 01111101

c 的原码二进制：10000000 00000000 00000000 01111110

转化为 10 进制为：-126

效果展示：

sizeof 括号内部的表达式也会发生整形提升：

#include <stdio.h>
int main()
{
	char a = 1;
	char b = 1;

	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(+a));
	printf("%d\n", sizeof(-a));
	printf("%d\n", sizeof(a+b));
	return 0;
}

sizeof 括号里面放入表达式是要进行整型提升的，因此打印出来是 4 。

效果展示：

6.2 算数转换

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

long double

double

float

unsigned long int

long int

unsigned int

int

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

6.3 操作符的属性

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

1.操作符的优先级

2.操作符的结合性

3.是否控制求值顺序

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

操作符优先级（从上到下逐级递减）：

在写表达式的时候需要谨慎一点，要不然会出问题，比如：

#include <stdio.h>

int main()
{
    int a = 3;
    int b = a + --a;

    return 0;
}

我们根据操作符优先级可以得出表达式 b 是先进行 --a 操作，再进行 + 操作。但是在进行 + 之前进行了 -- 操作，--a 是 1 ，+ 前面的 a 应该是 2 还是 1 ，结果不可预测，这就出现了歧义。

我们再看一个代码：

#include <stdio.h>
int fun()
{
    static int a = 1;
    return ++a;
}
int main()
{
    int ret = fun() - fun() * fun();
    printf("%d\n", ret);

    return 0;
}

分析：