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

妖狐艹你老母 2023-09-27 16:16 163阅读 0赞

**目录**

1、条件操作符

2、逗号表达式

3、下标引用操作符

4、函数调用操作符

5、结构成员

6、表达式求值

6.1 隐士类型转换

6.2 算数转换

6.3 操作符的属性

--------------------

## 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;
    }

*效果展示：*

![68471bc3cdf36168da84b8fbbb9c65de.png][]

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

**上面的 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;
    }

*效果展示：*

![d24e6f5e3a90dfbe20ee47397d2b09c0.png][]

## 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。**

*我们看展示效果：*

![97e574bb9deb2f0a9959f19c39874036.png][]

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

**再来看一段代码：**

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;
    }

*效果展示：*

![82aac79af0469287b3da0fd9c9a524dd.png][]

**这里我们使用 . 来访问。**

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

**如下：**

#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;
    }

*效果展示：*

![73c017ff4a3b8a698acbe97644c836d0.png][]

**传的是地址因此我们可以通过地址找到 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**

*效果展示：*

![3e70c3761a16ba7e35fe022e146aaa30.png][]

**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 。**

*效果展示：*

![9b1953815c4a99325eef0ca25bb8c027.png][]

### 6.2 算数转换 ###

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

> long double
> 
> double
> 
> float
> 
> unsigned long int
> 
> long int
> 
> unsigned int
> 
> int

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

### 6.3 操作符的属性 ###

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

**1.操作符的优先级**

**2.操作符的结合性**

**3.是否控制求值顺序**

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

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

![fcb67786d199ee4d086a652389f7148c.png][]

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

#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;
    }

**分析：**

![e2256e768bad7e8120be9b2fcb896a8d.png][]

**总结：****我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那么这个表达式就是存在问题的。**

**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*操作符篇完结\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***

[68471bc3cdf36168da84b8fbbb9c65de.png]: https://img-blog.csdnimg.cn/img_convert/68471bc3cdf36168da84b8fbbb9c65de.png
[d24e6f5e3a90dfbe20ee47397d2b09c0.png]: https://img-blog.csdnimg.cn/img_convert/d24e6f5e3a90dfbe20ee47397d2b09c0.png
[97e574bb9deb2f0a9959f19c39874036.png]: https://img-blog.csdnimg.cn/img_convert/97e574bb9deb2f0a9959f19c39874036.png
[82aac79af0469287b3da0fd9c9a524dd.png]: https://img-blog.csdnimg.cn/img_convert/82aac79af0469287b3da0fd9c9a524dd.png
[73c017ff4a3b8a698acbe97644c836d0.png]: https://img-blog.csdnimg.cn/img_convert/73c017ff4a3b8a698acbe97644c836d0.png
[3e70c3761a16ba7e35fe022e146aaa30.png]: https://img-blog.csdnimg.cn/img_convert/3e70c3761a16ba7e35fe022e146aaa30.png
[9b1953815c4a99325eef0ca25bb8c027.png]: https://img-blog.csdnimg.cn/img_convert/9b1953815c4a99325eef0ca25bb8c027.png
[fcb67786d199ee4d086a652389f7148c.png]: https://img-blog.csdnimg.cn/img_convert/fcb67786d199ee4d086a652389f7148c.png
[e2256e768bad7e8120be9b2fcb896a8d.png]: https://img-blog.csdnimg.cn/img_convert/e2256e768bad7e8120be9b2fcb896a8d.png