开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> 0基础学C语言（3）—— 超详解--＞《操作符》 -> 正文阅读

[C++知识库]0基础学C语言（3）—— 超详解--＞《操作符》

前言：写这个系列是把自己在学习C中的一些自认为的细节分享给CSDN的各位小伙伴，将自己切身认识到的知识、踩过的坑、不好理解的内容以这样一种方式展现在CSDN上，去帮助更多的小白和同伴，也是帮我自己巩固知识，沉淀基础的不二之选。希望大家可以在我的文章中有所收获，有什么建议可以在评论区提出 _感激不尽

一.操作符的类型：

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

1.1算数操作符：

+ - / * %

除了%操作符之外，其他的操作符都可以作用于整数和浮点数
对于 / 操作符如果两个操作数都是正数的话，执行的是整数除法，但是两个数字中只要有一个浮点数，那么执行的就是浮点数除法。
%的两个操作数必须是整数，返回的是整除之后的余数

1.2移位操作符(移动的是二进制位)

<<	左移操作符
>>	右移操作符

首先先补充一下位操作符的运算规则：

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

了解了具体规则之后再来看下面的题目

eg:

int a=16;

通过之前的学习可以知道：16的二进制数是：

 00000000000000000000000000010000.

如果此时 int b=a>>1;那么b的二进制数就变成了：

00000000000000000000000000001000

那么是怎么进行运算的呢？

? 首先要知道右移运算分两种：算术右移和逻辑右移

1.算术右移

整体右移（相当于整体平移，可以想象有一个框，其中包含32个数字，但是这个框是不动的，当你整体数字向右平移一个单位的时候，右边会出去一个数字，左边少一个数字。），缺的地方补原符号位（即原来是正数补0，原来负数补1），多余（出框）出的直接丢弃

通过之前的学习我们知道通过二进制数字中的首位的值，是可以进行判断数字正负的

例如：

16： 00000000000000000000000000010000

-16： 10000000000000000000000000010000

在这里插入图片描述

2.逻辑右移：（右边丢弃，左边补0)

但是我们怎么知道程序执行的是算数还是逻辑呢？

进行debug：很显然，正数的话两者都是一样的，无法判断是那种方法，用负数进行debug会更好。

假设 int a=-1；如果是算术右移，就会补原符号位（1）还是负数，如果是逻辑右移，就会补0，变成正数

所以可以得出结论，程序执行是算术右移，虽然有两种方式，但通常都是算术移动

举一个例子加强理解：

当我输入这样一个代码：

int main()
{
	int a = 16;
	int b = a >> 1;
	printf("%d", b);
	return 0;
}

得出的结果是：
在这里插入图片描述

可以看出如果不>>1 (右移1个单位)，16本身是10000（省略之前的0，下文也是），但是当>>1之后，二进制每个数字的权重都进行了右移，使得变为1000（也就是8），

如果我不>>1 ，而是int b=a>>2;呢？

继续来看
在这里插入图片描述

和上面一样 1的权重右移变成了100（4）。

通过这个不仅仅可以帮我们理解位置的移动，也顺便知道了：右移一位就相当于是 十进制数字/2

同理左移一位也是十进制数字*2

整数的二进制有三中表示方法：原码，反码，补码，存储到内存中的是补码，如果要真正计算移位的话，我们要先写出a的补码的形式，才可以进行下一步的运算

整数分成正负，正数原反补码都是一样的，所以可以直接进行移位操作

如果是负数呢？在上面我们知道了：负数的首数字是1开头再根据二进制，可以知道1的二进制数就是1(省略之前的0)，所以可以写出-1的二进制数：

100000000000000000000000000000001-----原码

111111111111111111111111111111110-----反码（符号位不变，其他位按位取反）（1->0,0->1)

111111111111111111111111111111111------补码（内存中真正的存储方式）（补码=反码+1）

这样我们就回顾了-1的三种表达方式，并且知道了-1的存在形式(二进制数字)32位都是1，那么到底这里是不是这个东西呢？

我们去编译器里详细看一下。当我在vs2019中打开-1的内存地址：
在这里插入图片描述

可以看到是8个f 很明显的确都是1(具体原因看下方解释) ，这么一来说明我们的计算是正确的

因为16进制表示方法中f=15 15换成二进制就是4个1，那么八个f就是32个1，得出的结论与我们上面相同

上图加强理解：

在这里插入图片描述

左移

那么说完了右移，左移是怎么一回事呢？继续看：.

不难看出，看起来是*2 ，其实和右移的根本规则是大同小异的

总结：左移的移动规则是左丢右补0（不论正负都是补0）

? 右移的移动规则是右丢左补原符号位

警告? ：

对于移位运算符，不要移动负数位，这个是标准未定义的。

例如：

int num = 10;

num>>-1;//error

不可以这样运算

1.3位操作符

注意：按位都是按照的二进制位

& 按位与 (按的是二进制与)

0&0=0; 0&1=0; 1&0=0; 1&1=1 同真则真，有假则假

eg：

int a=3;//a=011(省略前面0，下同)

int b=5;//b=101

int c=a&b; //c=001

printf("%d",c);

return 0;

不要忘记按位与的运算规则：同1则1，不同则0；
负数按补码形式参加按位与运算

注：他们的操作数必须是整数

来上手练习一下：

int main()

{

int num1 = 1;

int num2 = 2;

num1 & num2;

num1 | num2;

num1 ^ num2;

return 0;

}

带有逻辑的位操作符

| 按位或

运算方法与高中数学中的或是一样的，有1则1，同0则0

直接上代码：

int main()
{
int a = 3;//011
int b = 5;//101
int c = a | b;//111
printf("%d", c);
return 0;
}

再看结果，是一样的。
在这里插入图片描述

^ 按位异或

相同为0，不同为1

一道面试题(不能创建新的变量，交换两个数的值)：

法一：加减法

int main()
{
	int a = 10;
	int b = 20;
	a = a + b;
	b = a - b;
	a = a - b;
	printf("%d\n", a);
	printf("%d", b);
	return 0;
}

法二：异或法

int main()
{
	int a = 3;
	int b = 5;
	a = a ^ b;
	b = a ^ b;
	a = a ^ b;
	printf("%d %d ", a, b);
	return 0;
}

小技巧：可以将第一次a^b的值看成一个密码，当用这个密码异或a可以得到b的值，异或b可以得到a的值

并且异或是不可能存在进位的情况的

哪个方法更好？效率更高呢？

可读性效率都是法一要更好法二只是提供一个思路来做出这个面试题

方法一的确存在问题————>可能会导致整型溢出——>缓冲区溢出

方法二是要优于法一的。

再来一道题

例题二

编写代码实现：求一个整数存储在内存中的二进制中1的个数

`int main()`
`{`
	`int num = 0;`
	`int cnt = 0;`
	`scanf("%d" ,& num);`
	`//统计num的补码中有几个1`
	`while (num != 0)`
	`{`
		`if (num % 2 == 1)`
		`{`
			`cnt++;`
			`num /= 2;`
		`}`
	`}`
	`printf("%d\n", cnt);`
	`return 0;`
`}`

当我们输入正整数的时候，上面的代码是没有问题的（因为正数的原反补码均一致），但是如果是负数呢？
在这里插入图片描述

的确是一个值得我们深思的问题：

当我们输入-1时

-1%2==-1 ， -1/2==-1

int main()
{
	int num = 0;
	int cnt = 0;
	scanf("%d" ,&num);
	int i = 0;
	for (i = 0; i < 32; i++)
	{
		if (1 == ((num >> i) & 1))
		{
			cnt++;

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

//00000000000000000000000000000011
//00000000000000000000000000000001
//00000000000000000000000000000001
// 	 如果 num&1==1  cnt++,如果num&1==0,证明是0
//统计num的补码中有几个1

1.4赋值操作符

赋值操作符是一个很好用的操作符，可以任意的得到一个你之前不满意的值，

eg：

int weight=100;//你感到不满意

weight=80;//你完全可以把它改为80

并且它本身可以进行连续赋值:

eg: int a=10

int b=20;

int c=30;

并且如果你想的话还能简化理解难度

eg: int x=(y+1)*2;

可以拆分为 int v=y+1;

int x=v*2;

这样的写法有利于进行debug，并且更加清晰明了

1.5复合操作符

+= a=a+2 等价于 a+=2

-= a=a-2 等价于 a-=2

*= 下同

/=

%=

>>=

<<=

&=

|=

^=

1.6单目操作符

单目操作符的介绍

+是双目操作符（有两个操作数）

{笼统的理解{：有几个操作数就是几目}

! 逻辑反操作

- 负值

+ 正值

& 取地址

sizeof 操作数的类型长度（以字节为单位）

 对一个数的二进制按位取反

– 前置、后置–

++ 前置、后置++

* 间接访问操作符(解引用操作符)

(类型) 进行强制类型的变换

int a= 10;int* p = &a; //在这里&将a的地址取出存入p中
//p中就存放了这样一个地址那么既然p是用来存放地址的//我们就把它称为指针变量
//一般如果是整型的话就设置为 int* 同理如果要设置成浮点数就是float*
*p; //*在这里是解引用操作符，作用是通过p里面存的的值，从而找到这个对象

? //p 在这里就是a 即p==a`

sizeof和数组

数组也是分有类型的前面的int char 等决定了数组的类型

int a = 10;
char c = 'r';
char* p = &c;
int arr[10] = { 0 };
//sizeof计算的是变量(包括变量)所占内存空间的大小单位是字节
printf("%d\n", sizeof(a));//4
printf("%d\n", sizeof(c));//1
printf("%d\n", sizeof(p));//4 指针在32位的平台是4个字节 64位的平台是8个字节
printf("%d\n", sizeof(arr));//40
return 0;

尝试一下自己是否可以不看答案的情况下把答案计算出来吧

int a = 11;//把第三位给我改成1
a=a | (1 << 2);
//00000000000000000000000000001011   给它第三位(这个位是怎么计算的呢？思考一下 下面会给出解释)或一个0即可
//00000000000000000000000000000100   加入一个第三位是1的数进行或操作
//00000000000000000000000000001111
printf("%d\n",a);//打印的时候是打印原码  所以结果就是  a==-1

a++/++a

通俗的说 ++在哪里就是在哪里进行加和操作

比如：a++就是先进行赋值操作，在把a的值加1

? --a就是先把a的值减少1 ，在进行赋值

直接上代码帮助理解：

前置++ –

int a = 10;

int x = ++a; //先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。

int y =--a;//先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;

后置++和–

`int main()`

`{`

   `int a = 10;`

   `int x = a++;`

//先对a先使用，再增加，这样x的值是10；之后a变成11；

  `int y = a--;`

//先对a先使用，再自减，这样y的值是11；之后a变成10；

（类型）强制变换类型

假设我int a=3.14; 很明显这是错误的因为int类型是整型但是我给a赋值是一个浮点数，那么我们在不修改数字的情况下应该怎么办呢？

没错就是加个（）来进行强制的修改类型

int a=(float)3.14; 这样是不是就是正确了呢？思考一下~

1.7关系操作符

`>`

\>=

<

<=

!= 用于测试“不相等”

== 用于测试“相等”

1.8逻辑操作符

下面写出了 C 语言支持的所有关系逻辑运算符。假设变量 A == 1，变量 B == 0，则：

运算符描述实例

&&

称为逻辑与运算符。如果两个操作数都非零，则条件为真。 (A && B) 为假。

||

称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 (A || B) 为真。

!

称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 !(A && B) 为真。

注意：

区分逻辑与与和按位与

区分逻辑或和按位或**

更要特别注意：这里逻辑与和或有一个特殊的点：

来看看这道笔试题

\`#include <stdio.h>`

`int main()`

`{`

   `int i = 0,a=0,b=2,c =3,d=4;`

   `i = a++ && ++b && d++;`

   `//i = a++||++b||d++;`

   `printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);`

   `return 0;` 

`}`

//程序输出的结果是什么？思考一下评论区公布正确答案

条件操作符(三目操作符)

ex1？ex2：ex3

1.算一下这个结果

`if (a > 5)`

?     `b = 3;`

`else`

?     `b = -3;`

转换成条件表达式，是什么样？

其实就是 b= (a>5?3:-3)
其实就是通过ex1进行判断，

? (ex1?ex2:ex3) 转化过来的意思是：

如果符合ex1 -> 执行ex2

如果不符合 -> 执行ex3

2.还有一个很经典的例子：

使用三目操作符发来实现找两个数中较大值

max=(a>b?a:b)

是不是特别简单呢？

的确三目操作符在执行这样的情景时比其他语句更有优越性

1.9逗号表达式

顾名思义，就是用逗号隔开的多个表达式，并且它从左向右依次执行，最后整个表达式的结果是最后一个表达式的结果

代码1；

`int a = 1;`

`int b = 2;`

`int c = (a>b, a=b+10, a, b=a+1);//逗号表达式`

c是多少？先思考一下 稍后在评论区公布答案

代码二

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

在这里又是以哪一个为判断条件呢？

//代码3

`a = get_val();`

`count_val(a);`

`while (a > 0)` 

`{`

?     `//执行程序

?     `a = get_val();`

?     `count_val(a);`

`}`

如果把这样一段代码转化为逗号表达式写出来是什么效果呢？

`while(a=get_val(),count_val(a),a>0)`

`{`

`// 执行程序`

`}`

1.10 补充一点其他运算符

运算符	描述	实例
sizeof()	返回变量的大小。	sizeof(a) 将返回 4，其中 a 是整数。
&	返回变量的地址。	&a; 将给出变量的实际地址。
*	指向一个变量。	*a; 将指向一个变量。
? :	条件表达式	如果条件为真 ? 则值为 X : 否则值为 Y

二.下标引用、函数调用、结构成员操作符

1.[] 下标引用操作符

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

举个简单的栗子：

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

在这样一段代码中
得到的结果是 4
为什么是这样子？
如果不清楚的点击此处回顾数组下标访问
回顾数组内容(1.3—下标的索引与元素的关系)

过于简单不多赘述

2.()函数调用操作符

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

#include<stdio.h>

get_max(int x, int y)
{
int sum = x + y;
return sum;
}

int main()
{
int a = 10;
int b = 20;
get_max(a, b);
printf("%d", get_max);
return 0;
}

详解：在这段代码中，有三个操作数 get_max ， a ， b （但是对于函数来说，操作数最起码要有一个 {在不传参的时候}）

函数调用的时候是将get_max(a,b)中的 a,b 分别传到了上面的get_max函数中，并且函数int了两个变量来分别接受a,b的值(本质上x,y在这里是形参)

忘了形参的同学点击回顾一下什么是形参和实参

对于函数来说操作数最起码有一个

这个操作符现在先不详细说明在之后的博客会详细讲解

访问一个结构的成员

. ->操作符

struct STU//创造一个结构体类型类型名叫STU 就比如创建一个学生类型(结构体)
//可以通过不同条件去描述具体的一个人
{
char name[20];
int age;
char id[20];
}
int main()
{
int a = 10;
//使用STU这个类型创建了一个学生对象，并初始化
struct STU a1 = {"张三",20,"20210811"};//分别对应上面三个描述
return 0;
}

再来看一段代码：

\`#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;` 

`}`

在这里插入图片描述

如果想要访问结构体内成员就像图中一样打印 a1.__ 空格处填上你要寻找的信息

printf("%s\n", (*ps).name);

同理使用指针也是如此操作

<1>struct STU* ps = &a1;

<2>printf("%s\n ", (*ps).name);

还有一个更简单的方式

<3>printf("%s\n ",ps->name); ，的右边是 结构体指针->成员名

好了，学了这么多操作符，其根本目的是什么呢？单纯的学习知识吗？

并不是，其实是为了更好的帮助我们求表达式的值，

三.表达式求值

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

同事有些表达式在计算的过程中也可能需要转化为其他类型来进行计算

正比如下面的内容：

3.1隐式类型转换

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

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

提升。

3.2整型提升的意义：

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度

一般就是int的字节长度，同时也是CPU的通用寄存器的长度。

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

通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。

实例1

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中的a,b要进行整形提升,但是c不需要整形提升

a,b整形提升之后,变成了负数,所以表达式 a0xb6 ,，b0xb600 的结果是假,但是c不发生整形提升,则表

达式 c==0xb6000000 的结果是真.

所程序输出的结果是:

c

实例2：

c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字

节.

char c1 = -1;

变量c1的二进制位(补码)中只有8个比特位：

因为 char 为有符号的 char

所以整形提升的时候，高位补充符号位，即为1

提升之后的结果是：

11111111111111111111111111111111

正数的整形提升

char c2 = 1;

变量c2的二进制位(补码)中只有8个比特位（0x之后跟随的是16进制数字）：

00000001

因为 char 为有符号的 char

所以整形提升的时候，高位补充符号位，即为0

提升之后的结果是：

00000000000000000000000000000001

无符号整形提升，高位补0

实例3

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

`}`

所程序输出的结果是:

c

//实例2

`int main()`

`{`

 `char c = 1;`

 `printf("%u\n", sizeof(c));`//1

 `printf("%u\n", sizeof(+c));`//4   
 这里进行计算， 需要整型提升，所以大小是4

 `printf("%u\n", sizeof(-c));`//1

 `return 0;` 

`}`

实例2中的,c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字

节

表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof? ,就是1个字节.

算数转换（其实也是一种隐式类型转换）

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类

型，否则操作就无法进行。下面的层次体系称为寻常算术转换。

long double

double

float

unsigned long int

long int

unsigned int

int

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

算。

警告：

但是算术转换要合理，要不然会有一些潜在的问题

float f = 3.14;

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

操作符的属性，性质

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

操作符的优先级

操作符的结合性（优先级相同的情况下考虑结合性）

是否控制求值顺序。

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

操作符优先级

下面从书中找了一些表格(C和指针)

并且特别要注意一些表达式问题：

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

例题一

ab + cd + e*f

当代码1在计算的时候，由于**比+的优先级高，只能保证，***的计算是比+早，但是优先级并

不能决定第三个*比第一个+早执行。

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

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

你看，计算机的计算路径存在很多种，在写代码时要特别注意表达式的计算问题，尽可能要只有一种计算路径

再看一个：

例题二

c+ --c；

同样也是存在问题的一个表达式：

假设c=1，无疑我们要先进行自减再去进行加法操作，但是当右操作数变成0之后我们做操作数是取0还是取1？

这是一个有歧义的问题，所以不可以这样书写

所以，操作符的优先级只能决定自减–的运算在+的运算的前面，但是我们并没有办法得

知，+操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义

的。

再来加深印象（C与指针中的题）

例题3-非法表达式

`int main()`

`{`

 `int i = 10;`

 `i = i-- - --i * ( i = -3 ) * i++ + ++i;`

 `printf("i = %d\n", i);`

 `return 0;` 

`}`

表达式3在不同编译器中测试结果：非法表达式程序的结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1TXyNk4P-1628746660646)(C:\Users\顾冷\AppData\Roaming\Typora\typora-user-images\image-20210812125138911.png)]

在了解具体规则和特殊情况之后我们再来看一段代码

例题4

`int fun()`

`{`

   `static int count = 1;`

   `return ++count;` 

`}`

`int main()`

`{`

   `int answer;`

   `answer = fun() - fun() * fun();`

   `printf( "%d\n", answer);//输出多少？`

   `return 0;` 

`}`