操作符详解

矫情吗；* 2023-10-13 16:54 53阅读 0赞

### 操作符详解 ###

*  操作符分类
 *  算数操作符
 *  移位操作符（操作符是对补码进行操作）
 *   *  右移操作符
     *  左移操作符
 *  位操作符
 *   *  关于^的一道面试题
 *  复制操作符
 *  单目操作符
 *   *  小问题
 *  关系操作符
 *  逻辑操作符
 *  条件操作符
 *  逗号表达式
 *  下标引用，函数调用，结构成员
 *   *  下标引用
     *  函数调用
     *  结构成员
 *  表达式求值
 *   *  隐式类型转换
     *  算数转化
     *  操作符的属性

# 操作符分类 #

> 算术操作符  
> 移位操作符  
> 位操作符  
> 赋值操作符  
> 单目操作符  
> 关系操作符  
> 逻辑操作符  
> 条件操作符  
> 逗号表达式  
> 下标引用、函数调用和结构成员

# 算数操作符 #

+ - * / %

1.  除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
2.  对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
3.  % 操作符的两个操作数必须为整数。返回的是整除之后的余数。

# 移位操作符（操作符是对补码进行操作） #

## 右移操作符 ##

>> 右移操作符
    
    （算数操作符右边丢弃，左边补原来符号位）一般用这个
    
    （逻辑右移右边丢弃，左边直接补0）
    
    正整数原码反码补码相同
    
    正整数15
    
    原码为000000000000000000000000000001111；
    
    反码为000000000000000000000000000001111；
    
    补码为000000000000000000000000000001111；
    
    负整数-15
    
    原码为10000000000000000000000000001111；
    
    反码为11111111111111111111111111110000；除了符号位不变其他为1变0，0变1；
    
    补码为11111111111111111111111111110001；反码加1
    
    -15>>1
    
    补码为11111111111111111111111111111000；
    
    反码为11111111111111111111111111110111；
    
    补码减1（这里的减1是借前前一位的1相当于112-1，借1就是把这为变成2）；
    
    原码为10000000000000000000000000001000；反码除了符号位不变其他为1变0，0变1；

## 左移操作符 ##

<<左移操作符
    左移操作符
    
    左边丢弃右边补0；

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

# 位操作符 #

#include <stdio.h>
    int main() {
        
    	int a = 3;
    	//补码00000000000000000000000000000011
    	int b = -5;
    	//原码10000000000000000000000000000101
    	//反码11111111111111111111111111111010
    	//补码11111111111111111111111111111011
    	int c = a & b;
    	//规则有0则0两个都是1才是1
    	//补码00000000000000000000000000000011
    	//补码11111111111111111111111111111011
    	//c 为00000000000000000000000000000011
    	printf("&操作符操作后%d\n", c);
    	int n = a | b;
    	//规则有1则1
    	//补码00000000000000000000000000000011
    	//补码11111111111111111111111111111011
     //n补码为11111111111111111111111111111011
     //n反码为11111111111111111111111111111010
     //n原码为10000000000000000000000000000101
    	printf("|操作符操作后%d\n", n);
    	int y = a ^ b;
    	//规则对应二进制相同为0不同为1
    	//补码00000000000000000000000000000011
    	//补码11111111111111111111111111111011
     //y补码为11111111111111111111111111111000
     //y反码为11111111111111111111111111110111
     //y原码为10000000000000000000000000001000
    	printf("^操作符操作后%d\n", y);
    	
    	system("pause");
    }

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

## 关于^的一道面试题 ##

问题为如何不创建临时变量交换两个数

a^a=a;
    a^0=0;//因为0的二进制补码全为0，
    a^b^a=b;
    a^a^b=b;
    //说明^有交换律

#include <stdio.h>
    int main() {
        
    	int a = 1;
    	int b = 2;
    	printf("没交换前a=%d b=%d\n", a, b);
    	a = a + b;
    	b = a - b;
    	a = a - b;
    	printf("交换后a=%d b=%d\n", a, b);
    	a = a ^ b;
    	b = a ^ b;//将a带入b=(a^b)^b=a
    	a = a ^ b;//将a和b带入a=(a^b)^a=b
    	printf("再次交换后a=%d b=%d\n", a, b);
    	system("pause");
    }

# 复制操作符 #

合赋值符
    +=
    -=
    *=
    /=
    %=
    >>=
    <<=
    &=
    |=
    ^=

# 单目操作符 #

! 逻辑反操作
    - 负值
    + 正值
    & 取地址
    sizeof 操作数的类型长度（以字节为单位）
    ~ 对一个数的二进制按位取反
    -- 前置、后置--
    ++ 前置、后置++
    * 间接访问操作符(解引用操作符)
    (类型) 强制类型转换

演示代码：
    关于sizeof其实我们之前已经见过了，可以求变量（类型）所占空间的大小。
    #include <stdio.h>
    int main()
    {
        
    int a = -10;
    int *p = NULL;
    printf("%d\n", !2);
    printf("%d\n", !0);
    a = -a;
    p = &a;
    int arr[10]={
        0};
    printf("%d\n", sizeof(a));
    printf("%d\n", sizeof(int));
    printf("%d\n", sizeof a);//这样写行不行？行括号能去掉说明不是函数
    printf("%d\n", sizeof int);//这样写行不行？
    printf("%d\n", sizeof(arr));//特殊的数组名代表整个数组大小
    printf("%d\n", sizeof(int [10]));
    return 0;
    }

~操作符代码演示

#include <stdio.h>
    int main() {
        
    	int a = 10;
    	//补码00000000000000000000000000001010
    	//取反11111111111111111111111111110101
    	//反码11111111111111111111111111110100
    	//原码10000000000000000000000000001011
    	printf("%d", ~a);//-11；
    	system("pause");
    }

## 小问题 ##

```c
    #include <stdio.h>
    void test1(int arr[])
    {
        
    printf("%d\n", sizeof(arr));//(2)
    }
    void test2(char ch[])
    {
        
    printf("%d\n", sizeof(ch));//(4)
    }
    int main()
    {
        
    int arr[10] = {
        0};
    char ch[10] = {
        0};
    printf("%d\n", sizeof(arr));//(1)
    printf("%d\n", sizeof(ch));//(3)
    test1(arr);
    test2(ch);
    return 0;
    }
    问：
    （1）、（2）两个地方分别输出多少？
    （3）、（4）两个地方分别输出多少？

# 关系操作符 #

>
    >=
    <
    <=
    != 用于测试“不相等”
    == 用于测试“相等”

自行理解

# 逻辑操作符 #

> && 逻辑与（左边为0右边就不算了）  
> || 逻辑或（左边为1右边就不算了）

#include <stdio.h>
    int main（）{
        
    
    int i = 0,a=0,b=2,c =3,d=4;
    i = a++ && ++b && d++;//a为0右边不计算了
    //i = a++||++b||d++;
    printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);//1,2,3,4
    return 0;
    }

# 条件操作符 #

![在这里插入图片描述][469ce91a86a44898809c1397dc9a3b0f.png]  
三目运算符

> exp1表达式为真整个表达式为exp2  
> exp1表达式为假整个表达式为exp3

代码实现

#define _CRT_SECURE_NO_WARNINGS 1
    #include <stdio.h>
    int main() {
        
    	int a = 0;
    	int b = 0;
    	scanf("%d %d", &a, &b);
    	int max = a > b ? a : b;//如果a>b,max=a,反之则为max=b;
    	printf("%d", max);
    }

上面的代码还可以表示为

#define _CRT_SECURE_NO_WARNINGS 1
    #include <stdio.h>
    int main() {
        
    	int a = 0;
    	int b = 0;
    	scanf("%d %d", &a, &b);
    	int max = 0;
    	if (a > b) {
        
    		max = a;
    	}else{
        
    		max = b;
    	}
    	printf("%d",max);
    }

# 逗号表达式 #

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

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

int a = 1;
    int b = 2;
    int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
    c是多少
    答案是13（从左往右依次计算，c就是最后一个表达式的值）；

# 下标引用，函数调用，结构成员 #

## 下标引用 ##

1.\[ \] 下标引用操作符  
操作数：一个数组名 + 一个索引值  
说白了就是数组中下标

int arr[10]={
        1,2,3,4,5,6,7,8,9,10};
    printf("%d",arr[0]);

arr\[0\]就能找到数组中下标为0的值1

## 函数调用 ##

函数名加（）括号里是参数  
特殊的是printf（）；他的参数是可变参数列表

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

## 结构成员 ##

访问一个结构的成员  
. 结构体.成员名  
\-> 结构体指针->成员名  
第一种方式

struct yinyue {
        
    	char arr[10];
    	char sum[100];
    };
    int main() {
        
    	struct yinyue p = {
         "周杰伦","我落泪情绪零碎" };
    	printf("%s的作者是%s", p.sum, p.arr);
    	system("pause");
    }

第二种方式（不同的是结构体地址访问成员变量）

struct yinyue {
        
    	char arr[10];
    	char sum[100];
    };
    print(struct yinyue* p) {
        
    	printf("%s的作者是%s", p->sum, p->arr);
    }
    int main() {
        
    	struct yinyue p = {
         "周杰伦","我落泪情绪零碎" };
    	print(&p);
    	system("pause");
    }

# 表达式求值 #

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

int main() {
        
    	int a = 1;
    	int b = 2;
    	int c = 1 + a * b;//*优先级较高
    }

## 隐式类型转换 ##

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

![2adf252c8eb24cfba451fdda5896fd8f.png][]

> 1.cpu运算时都是标准长度，都要提供四字节空间  
> 2.cpu运算很难用8比特位进行计算所以要转为int或unsigned int才好运算  
> 3.并且char相加进位有可能会丢位

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

int main() {
        
    	char a = 5;
    	//二进制00000000000000000000000000000101
    	//截断后为00000101
    	char b = 127;
    	//二进制00000000000000000000000001111111
    	//截断后为01111111
    	char c = a + b;
    	//a整形提升00000000000000000000000000000101
    	//b整形提升00000000000000000000000001111111
    	//c为      00000000000000000000000010000100
    	//截断后为10000100
    	printf("%d",c);
    	//c整形提升11111111111111111111111110000100
    	//反码为   11111111111111111111111110000011
    	//补码为   10000000000000000000000001111100
    }

//实例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整形提升之后,变成了负数,所以表达式 a0xb6 , b0xb600 的结果是假,但是c不发生整形提升,则表  
> 达式 c==0xb6000000 的结果是真.  
> 所程序输出的结果是:  
> c

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

> //%u打印10进制无符号位（二进制是否看成符号）  
> 实例2中的,  
> c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字  
> 节.  
> 表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof© ,就是1个字节.

## 算数转化 ##

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类  
型，否则操作就无法进行。下面的层次体系称为寻常算术转换。（转换规则如下图箭头从低到高）  
![在这里插入图片描述][51c145069bfa4de4bb39b3cee83cc1d4.png]

int a=0;
    float b=1.0f;
    float c=a+b

## 操作符的属性 ##

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

1.  操作符的优先级
2.  操作符的结合性
3.  是否控制求值顺序。  
    两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。  
    操作符优先级

int fun()
    {
        
    static int count = 1;
    return ++count;
    }
    int main()
    {
        
    int answer;
    answer = fun() - fun() * fun();
    printf( "%d\n", answer);//输出多少？
    return 0;
    }
    这个代码有没有实际的问题？
    有问题！
    虽然在大多数的编译器上求得结果都是相同的。
    但是上述代码 answer = fun() - fun() * fun(); 中我们只能通过操作符的优先级得知：先算乘法，
    再算减法。
    函数的调用先后顺序无法通过操作符的优先级确定。

#include <stdio.h>
    int main()
    {
        
    int i = 1;
    int ret = (++i) + (++i) + (++i);
    printf("%d\n", ret);
    printf("%d\n", i);
    return 0;
    }
    //尝试在linux 环境gcc编译器，VS2013环境下都执行，看结果。

linux运行  
10  
4  
vs运行  
12  
4  
看看同样的代码产生了不同的结果，这是为什么？  
简单看一下汇编代码.就可以分析清楚.  
这段代码中的第一个 + 在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级  
和结合性是无法决定第一个 + 和第  
三个前置 ++ 的先后顺序。  
**总结：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题  
的。**

[ee43adb823f8460f833d1998da72d72b.png]: https://img-blog.csdnimg.cn/ee43adb823f8460f833d1998da72d72b.png
[777de718d3574fafab41ac81194577aa.png]: https://img-blog.csdnimg.cn/777de718d3574fafab41ac81194577aa.png
[469ce91a86a44898809c1397dc9a3b0f.png]: https://img-blog.csdnimg.cn/469ce91a86a44898809c1397dc9a3b0f.png
[ac8689290407408294dbab7948bd844f.png]: https://img-blog.csdnimg.cn/ac8689290407408294dbab7948bd844f.png
[2adf252c8eb24cfba451fdda5896fd8f.png]: https://img-blog.csdnimg.cn/2adf252c8eb24cfba451fdda5896fd8f.png
[51c145069bfa4de4bb39b3cee83cc1d4.png]: https://img-blog.csdnimg.cn/51c145069bfa4de4bb39b3cee83cc1d4.png