C语言入门篇（九）

朱雀 2024-04-23 20:28 5阅读 0赞

> **前言**  
> 　　本篇分享的是部分操作符的概念与用法，从经典例题入手，带你快速了解和掌握。  
> 　　收录专栏：[浅谈C语言][C]

#### 操作符详解下 ####

*  10. 逗号表达式
 *  11. 下标引用、函数调用和结构成员
 *  12. 表达式求值
 *   *  12.1 隐士类型转换
     *  12.2 算术转换
     *  12.3 操作符的属性

## 10. 逗号表达式 ##

exp1,exp2,exp3,...expN

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

//代码1
    int main() {
        
    	int a = 1;
    	int b = 2;
    	int c = (a > b, a = b + 10, a, b = a + 1);//逗号表达式
    	printf("%d\n", c);//13
    	return 0;
    }

//代码2
    int main() {
        
    	int a = 1, b = 3, c,d = 0;
    	if (a = b + 1, c = a / 2, d > 0); {
        
    		printf("hello");//hello
    	}
    	return 0;
    }

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

1.  **\[ \] 下标引用操作符**  
    操作数：一个数组名 + 一个索引值

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

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

#include <stdio.h>
     void test1()
     {
        
    	 printf("hehe\n");
     }
     void test2(const char *str)
     {
        
     	printf("%s\n", str);
     }
     int main()
     {
        
     	test1();            //实用（）作为函数调用操作符。
     	test2("hello bit.");//实用（）作为函数调用操作符。
    	 return 0;
     }

1.  **访问一个结构的成员**

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

#include <stdio.h>
    struct Stu
    {
        
    	char name[10];
    	int age;
    	char sex[5];
    	double score;
    };
    void set_age1(struct Stu stu)
    {
        
    	stu.age = 18;
    }
    void set_age2(struct Stu* pStu)
    {
        
    	pStu->age = 18;//结构成员访问
    }
    int main()
    {
        
    	struct Stu stu;
    	struct Stu* pStu = &stu;//结构成员访问
    
    	stu.age = 20;//结构成员访问
    	set_age1(stu);
    
    	pStu->age = 20;//结构成员访问
    	set_age2(pStu);
    	return 0;
    }

## 12. 表达式求值 ##

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

### 12.1 隐士类型转换 ###

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

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

**实例：**

char a,b,c;
    ...
    a = b + c;

b和c的值被提升为普通整型，然后再执行加法运算。  
加法运算完成之后，结果将被截断，然后再存储于a中。

**如何进行整体提升呢？**  
整形提升是按照变量的数据类型的符号位来提升的。

//负数的整形提升
    char c1 = -1;
    变量c1的二进制位(补码)中只有8个比特位：
    1111111
    因为 char 为有符号的 char
    所以整形提升的时候，高位补充符号位，即为1
    提升之后的结果是：
    11111111111111111111111111111111

//正数的整形提升
    char c2 = 1;
    变量c2的二进制位(补码)中只有8个比特位：
    00000001
    因为 char 为有符号的 char
    所以整形提升的时候，高位补充符号位，即为0
    提升之后的结果是：
    00000000000000000000000000000001
    
    //无符号整形提升，高位补0

**整形提升的例子：**

//实例1
    int main()
    {
        
    	char a = 0xb6;
    	short b = 0xb600;
    	int c = 0xb6000000;
    	if (a == 0xb6)
    		printf("a");
    	if (b == 0xb600)
    		printf("b");
    	if (c == 0xb6000000)
    		printf("c");
    	return 0;
    }

实例1中的a，b要进行整形提升，但是c不需要整形提升a，b整形提升之后变成了负数，所以表达式 a == 0xb6，b == 0xb600 的结果是假，但是c不发生整形提升，则表达式 c==0xb6000000 的结果是真。

🍤*运行结果：*

![在这里插入图片描述][bfbfdd7edb4b4b79a06e801e3ae72e91.png]

//实例2
    int main()
    {
        
    	char c = 1;
    	printf("%u\n", sizeof(c));//1
    	printf("%u\n", sizeof(+c));//4
    	printf("%u\n", sizeof(-c));//4
    	return 0;
    }

实例2中的，c只要参与表达式运算，就会发生整形提升，表达式 +c，就会发生提升，所以 sizeof(+c) 是4个字节。  
表达式 -c 也会发生整形提升，所以 sizeof(-c) 是4个字节，但是 sizeof(c），就是1个字节。

### 12.2 算术转换 ###

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

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

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

注： 算术转换要合理。  
例如下面这段代码进行转换时，精度会有丢失：

float f = 3.14;
    int num = f;//隐式转换，会有精度丢失

### 12.3 操作符的属性 ###

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

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

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

操作符优先级：

<table> 
 <thead> 
  <tr> 
   <th>操作符</th> 
   <th>描述</th> 
   <th>用法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>（）</td> 
   <td>聚组</td> 
   <td>（表达式）</td> 
  </tr> 
  <tr> 
   <td>（）</td> 
   <td>函数调用</td> 
   <td>rexp（rexp，…,rexp）</td> 
  </tr> 
  <tr> 
   <td>[ ]</td> 
   <td>下标引用</td> 
   <td>rexp[rexp]</td> 
  </tr> 
  <tr> 
   <td>.</td> 
   <td>访问结构成员</td> 
   <td>lexp.member_name</td> 
  </tr> 
  <tr> 
   <td>-&gt;</td> 
   <td>访问结构指针成员</td> 
   <td>rexp-&gt;member_name</td> 
  </tr> 
  <tr> 
   <td>++</td> 
   <td>后缀自增</td> 
   <td>lexp ++</td> 
  </tr> 
  <tr> 
   <td>–</td> 
   <td>后缀自减</td> 
   <td>lexp –</td> 
  </tr> 
  <tr> 
   <td>!</td> 
   <td>逻辑反 !</td> 
   <td>rexp</td> 
  </tr> 
  <tr> 
   <td>~</td> 
   <td>按位取反</td> 
   <td>~ rexp</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>单目，表示正值</td> 
   <td>+ rexp</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>单目，表示负值</td> 
   <td>- rexp</td> 
  </tr> 
  <tr> 
   <td>++</td> 
   <td>前缀自增</td> 
   <td>++ lexp</td> 
  </tr> 
  <tr> 
   <td>–</td> 
   <td>前缀自减</td> 
   <td>– lexp</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>间接访问</td> 
   <td>* rexp</td> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>取地址</td> 
   <td>&amp; lexp</td> 
  </tr> 
  <tr> 
   <td>sizeof</td> 
   <td>取其长度，以字节表示</td> 
   <td>sizeof rexp sizeof(类型)</td> 
  </tr> 
  <tr> 
   <td>(类型）</td> 
   <td>类型转换</td> 
   <td>(类型) rexp</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>乘法</td> 
   <td>rexp * rexp</td> 
  </tr> 
  <tr> 
   <td>/ 除法</td> 
   <td>rexp / rexp</td> 
   <td>rexp</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>整数取余</td> 
   <td>rexp % rexp</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>加法</td> 
   <td>rexp + rexp</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>减法</td> 
   <td>rexp - rexp</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>左移位</td> 
   <td>rexp &lt;&lt; rexp</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>右移位 rexp &gt;&gt; rexp</td> 
   <td>rexp</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>大于</td> 
   <td>rexp &gt; rexp</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>大于等于</td> 
   <td>rexp &gt;= rexp</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>小于</td> 
   <td>rexp &lt; rexp</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>小于等于</td> 
   <td>rexp &lt;= rexp</td> 
  </tr> 
  <tr> 
   <td>==</td> 
   <td>等于</td> 
   <td>rexp == rexp</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>不等于</td> 
   <td>rexp != rexp</td> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>位与</td> 
   <td>rexp &amp; rexp</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>位异或</td> 
   <td>rexp ^ rexp</td> 
  </tr> 
  <tr> 
   <td>&amp;&amp;</td> 
   <td>逻辑与</td> 
   <td>rexp &amp;&amp; rexp</td> 
  </tr> 
  <tr> 
   <td>? :</td> 
   <td>条件操作符</td> 
   <td>rexp ? rexp : rexp</td> 
  </tr> 
  <tr> 
   <td>=</td> 
   <td>赋值</td> 
   <td>lexp = rexp</td> 
  </tr> 
  <tr> 
   <td>+=</td> 
   <td>以…加</td> 
   <td>lexp += rexp</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>以…减</td> 
   <td>lexp -= rexp</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>以…乘</td> 
   <td>lexp *= rexp</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>以…除</td> 
   <td>lexp /= rexp</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>以…取模</td> 
   <td>lexp %= rexp</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;=</td> 
   <td>以…左移</td> 
   <td>lexp &lt;&lt;= rexp</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;=</td> 
   <td>以…右移</td> 
   <td>lexp &gt;&gt;= rexp</td> 
  </tr> 
  <tr> 
   <td>&amp;=</td> 
   <td>以…与</td> 
   <td>lexp &amp;= rexp</td> 
  </tr> 
  <tr> 
   <td>^=</td> 
   <td>以…异或</td> 
   <td>lexp ^= rexp</td> 
  </tr> 
  <tr> 
   <td>，</td> 
   <td>逗号</td> 
   <td>rexp，rexp</td> 
  </tr> 
 </tbody> 
</table>

`🍩表达式的求值部分由操作符的优先级决定。`

**例如：**

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

> 这段代码在计算的时候，由于 \* 比+的优先级高，只能保证，\* 的计算是比 + 早，但是优先级并不能决定第三个 \* 比第一个 + 早执行。

所以表达式的计算机顺序就可能是：

a*b
    c*d
    a*b + c*d
    e*f
    a*b + c*d + e*f
    //或者
    a*b
    c*d
    e*f
    a*b + c*d
    a*b + c*d + e*f

`🍩的调用先后顺序无法通过操作符的优先级确定。`

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

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

![在这里插入图片描述][9e4d302f64ad420fa72cba12f4094d44.png]

[C]: http://t.csdn.cn/OOWrp
[bfbfdd7edb4b4b79a06e801e3ae72e91.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/a2e1b8d0e6694c739e85a39d71379f7b.png
[9e4d302f64ad420fa72cba12f4094d44.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/f8df0e8e27b6439aadad34e47cb15a13.png