一、操作符的分类

• 算术操作符： + 、- 、* 、/ 、%
• 移位操作符: << >>
• 位操作符: & | ^
• 赋值操作符: = 、+= 、 -= 、 *= 、 /= 、%= 、<<= 、>>= 、&= 、|= 、^=
• 单目操作符： ！、++、–、&、*、+、-、~ 、sizeof、(类型)
• 关系操作符: > 、>= 、< 、<= 、 == 、 !=
• 逻辑操作符： && 、||
• 条件操作符：？ ：
• 逗号表达式： ,
• 下标引用： []
• 函数调用： ()
• 结构成员访问： . 、->

hello，宝子们！今天先介绍前半部分操作符，操作符中有一些操作符和二进制有关系，我们先铺垫一下二进制和进制转换的知识。

二、二进制和进制转换

其实我们经常能听到2进制、8进制、10进制、16进制这样的讲法，那是什么意思呢？其实2进制、8进制、10进制、16进制是数值的不同表示形式而已。
比如：数值15的各种进制的表示形式：

15的2进制 ：1111
15的8进制 ：17
15的10进制：15
15的16进制：F

我们重点介绍一下二进制：
首先我们还是得从10进制讲起，其实10进制是我们生活中经常使用的，我们已经形成了很多尝试：

• 10进制中满10进1
• 10进制的数字每一位都是0~9的数字组成，其实二进制也是一样的
• 2进制中满2进1
• 2进制的数字每一位都是0~1的数字组成，那么 1101 就是二进制的数字了。

1.2进制转10进制

其实10进制的123表示的值是一百二十三，为什么是这个值呢？其实10进制的每⼀位是权重的，10进制的数字从右向左是个位、十位、百位…，分别每一位的权重是 10 ,10 ,10 …
如下图：

2进制和10进制是类似的，只不过2进制的每一位的权重，从右向左是: 2 ,2 ,2 …
如果是2进制的1101，该怎么理解呢？

2.10进制转2进制

3.2进制转8进制

8进制的数字每一位是0到7的，0~7的数字，各自写成2进制，最多有3个2进制位就足够了，比如7的二进制是111，所以在2进制转8进制数的时候，从2进制序列中右边低位开始向左每3个2进制位会换算一个8进制位，剩余不够3个2进制位的直接换算。
如：2进制的01101011，换成8进制：0153，0开头的数字，会被当做8进制。

4.2进制转16进制

16进制的数字每⼀位是0到9,a到f的数字，各自写成2进制，最多有4个2进制位就足够了，比如f的二进制是1111，所以在2进制转16进制数的时候，从2进制序列中右边低位开始向左每4个2进制位会换算一个16进制位，剩余不够4个二进制位的直接换算。
如：2进制的01101011，换成16进制：0x6b，16进制表示的时候前面加0x

三、原码、反码、补码

整数的2进制表示方法有三种，即原码、反码和补码
有符号整数的三种表示方法均有符号位和数值位两部分，2进制序列中，最高位的1位是被当做符号位，剩余的都是数值位。
符号位都是用0表示“正”，用1表示“负”。
正整数的原、反、补码都相同。
负整数的三种表示方法各不相同。
原码： 直接将数值按照正负数的形式翻译成二进制得到的就是原码。
反码： 将原码的符号位不变，其他位依次按位取反就可以得到反码。
补码： 反码+1就得到补码。
反码得到原码也是可以使用：取反，+1的操作。
对于整形来说：数据存放内存中其实存放的是补码。
为什么呢？
在计算机系统中，数值⼀律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统一处理；同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

四、算术操作符+、-、*、/、%

在写代码时候，一定会涉及到计算。
C语言中为了方便运算，提供了一系列操作符，其中有一组操作符叫：算术操作符。分别是： + - */ % ，这些操作符都是双目操作符。
注：操作符也被叫做：运算符，是不同的翻译，意思是一样的。

1.+和-

+和-用来完成加法和减法。
+和-都是有2个操作数的，位于操作符两端的就是它们的操作数，这种操作符也叫双目操作符。

#include <stdio.h>
int main()
{
	int x = 4 + 22;
	int y = 61 - 23;
	printf("%d\n", x);
	printf("%d\n", y);
	return 0;
}

2.*

运算符 * 用来完成乘法。

#include <stdio.h>
int main()
{
	int num = 5;
	printf("%d\n", num * num); // 输出 25
	return 0;
}

3./

运算符 / 用来完成除法。
除号的两端如果是整数，执行的是整数除法，得到的结果也是整数。

#include <stdio.h>
int main()
{
	float x = 6 / 4;
	int y = 6 / 4;
	printf("%f\n", x); // 输出 1.000000
	printf("%d\n", y); // 输出 1
	return 0;
}

上面示例中，尽管变量 x 的类型是 float （浮点数），但是 6 / 4 得到的结果是 1.0 ，而不是1.5 。原因就在于C语言里面的整数除法是整除，只会返回整数部分，丢弃小数部分。
如果希望得到浮点数的结果，两个运算数必须至少有一个浮点数，这时C语言就会进行浮点数除法。

#include <stdio.h>
int main()
{
	float x = 6.0 / 4; // 或者写成 6 / 4.0
	printf("%f\n", x); // 输出 1.500000
	return 0;
}

上面示例中， 6.0 / 4 表示进行浮点数除法，得到的结果就是 1.5 。
再看⼀个例子：

#include <stdio.h>
int main()
{
	int score = 5;
	score = (score / 20) * 100;
	return 0;
}

上面的代码，你可能觉得经过运算， score 会等于 25 ，但是实际上 score 等于 0 。这是因为score / 20 是整除，会得到⼀个整数值 0 ，所以乘以 100 后得到的也是 0 。
为了得到预想的结果，可以将除数 20 改成 20.0 ，让整除变成浮点数除法。

#include <stdio.h>
int main()
{
	int score = 5;
	score = (score / 20.0) * 100;
	return 0;
}

4.%

运算符 % 表示求模运算，即返回两个整数相除的余值。这个运算符只能用于整数，不能用于浮点数。

#include <stdio.h>
int main()
{
	int x = 6 % 4; // 2
	return 0;
}

负数求模的规则是，结果的正负号由第⼀个运算数的正负号决定。

#include <stdio.h>
int main()
{
	printf("%d\n", 11 % -5); // 1
	printf("%d\n",-11 % -5); // -1
	printf("%d\n",-11 % 5); // -1
	return 0;
}

上面示例中，第⼀个运算数的正负号（ 11 或 -11 ）决定了结果的正负号。

五、移位操作符

注：移位操作符的操作数只能是整数。

1.左移操作符

移位规则：左边抛弃、右边补0

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

2.右移操作符

移位规则：首先右移运算分两种：

1.逻辑右移：左边用0填充，右边丢弃
2.算术右移：左边用原该值的符号位填充，右边丢弃

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

警告⚠ ：对于移位运算符，不要移动负数位，这个是标准未定义的。
例如：

int num = 10;
num>>-1; //error

六、位操作符：&、|、^、~

位操作符有：

• & 按位与：双目操作符，参与运算的两个值，转换成2进制，如果两个相应位均为1时，结果位才为1，否则为0。
• | 按位或：双目操作符，参与运算的两个值，转换成2进制，如果两个数的相应位有1时，结果就为1。
• ^ 按位异或：双目操作符，参与运算的两个值，转换成2进制，如果两个数的相应位相同，为0，否则为1.
• ~ 按位取反：单目操作符，参与运算的一个值，转换成2进制，可以将二进制数每个位取反，即0变为1,1变为0。

注：他们的操作数必须是整数。
直接上代码：

#include <stdio.h>
int main()
{
	int num1 = -3;
	int num2 = 5;
	printf("%d\n", num1 & num2);
	printf("%d\n", num1 | num2);
	printf("%d\n", num1 ^ num2);
	printf("%d\n", ~0);
	return 0;
}

下来看一道变态的面试题：
不能创建临时变量（第三个变量），实现两个数的交换。
相信这道题目大家都会，但是来见证一下更加新奇的一种思路吧，一定会让你脑洞大开的。

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

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

参考代码：
//⽅法1
#include <stdio.h>
int main()
{
	int num = 10;
	int count= 0; //计数
	while(num)
	{
		if(num%2 == 1)
		count++;
		num = num/2;
	}
	printf("⼆进制中1的个数 = %d\n", count);
	return 0;
}

//思考这样的实现方式有没有问题？
//⽅法2：
#include <stdio.h>
int main()
{
	int num = -1;
	int i = 0;
	int count = 0; //计数
	for(i=0; i<32; i++)
	{
		if( num & (1 << i) )
		count++;
	}
	printf("⼆进制中1的个数 = %d\n",count);
	return 0;
}

//思考还能不能更加优化，这⾥必须循环32次的。
//⽅法3：
#include <stdio.h>
int main()
{
	int num = -1;
	int i = 0;
	int count = 0; //计数
	while(num)
	{
		count++;
		num = num&(num-1);
	}
	printf("⼆进制中1的个数 = %d\n",count);
	return 0;
}
//这种⽅式是不是很好？达到了优化的效果，但是难以想到。

练习2：二进制位置0或者置1
编写代码将13⼆进制序列的第5位修改为1，然后再改回0

13的2进制序列： 00000000000000000000000000001101
将第5位置为1后：00000000000000000000000000011101
将第5位再置为0：00000000000000000000000000001101

参考代码：

#include <stdio.h>
int main()
{
	int a = 13;
	a = a | (1<<4);
	printf("a = %d\n", a);
	a = a & ~(1<<4);
	printf("a = %d\n", a);
	return 0;
}

七、赋值操作符：=和复合赋值

在变量创建的时候给一个初始值叫初始化，在变量创建好后，再给一个值，这叫赋值。

int a = 100; //初始化
a = 200; //赋值，这⾥使⽤的就是赋值操作符

赋值操作符 = 是一个随时可以给变量赋值的操作符。

1.连续赋值

赋值操作符也可以连续赋值，如：

int a = 3;
int b = 5;
int c = 0;
c = b = a+3; //连续赋值，从右向左依次赋值的。

C语言虽然支持这种连续赋值，但是写出的代码不容易理解，建议还是拆开来写，这样方便观察代码的执行细节。

int a = 3;
int b = 5;
int c = 0;
b = a+3;
c = b;

这样写，在调试的是，每一次赋值的细节都是可以很方便的观察的。

2.复合赋值符

在写代码时，我们经常可能对一个数进行自增、自减的操作，如下代码：

int a = 10;
a = a+3;
a = a-2;

这样代码C语言给提供了更加方便的写法：

int a = 10;
a += 3;
a -= 2;

C语言中提供了复合赋值符，方便我们编写代码，这些赋值符有：

 +=     -= 
 *=     /=    %=
>>=    <<=
 &=     |=    ^=

八、 单目操作符

1.逻辑反操作符 ！

比如，我们有一个变量叫 flag ,如果flag为假，要做⼀个什么事情，就可以这样写代码：

#include <stdio.h>
int main()
{
	int flag = 0;
	if(!flag)
	{
		printf("do something\n");
	}
	return 0;
}

如果 flag 为真， !flag 就是假，如果 flag 为假， !flag 就是真所以上面的代码的意思就是 flag 为假，执行if语句中的代码。

2.自增和自减操作符 ++、–

++是一种自增的操作符，又分为前置++和后置++，–是一种自减的操作符，也分为前置–和后置–。
前置++

int a = 10;
int b = ++a; //++的操作数是a，是放在a的前⾯的，就是前置++
printf("a=%d b=%d\n",a , b);

计算口诀： 先+1，后使用
a原来是10，先+1，后a变成了11，再使用就是赋值给b，b得到的也是11，所以计算技术后，a和b都是11，相当于这样的代码：

int a = 10;
a = a+1;
b = a;
printf("a=%d b=%d\n",a , b);

后置++

int a = 10;
int b = a++; //++的操作数是a，是放在a的后⾯的，就是后置++
printf("a=%d b=%d\n",a , b);

计算口诀： 先使用，后+1
a原来是10，先使用，就是先赋值给b，b得到了10，然后再+1，然后a变成了11，所以直接结束后a是11，b是10，相当于这样的代码：

int a = 10;
int b = a;
a = a+1;
printf("a=%d b=%d\n",a , b);

前置–
如果你听懂了前置++，那前置–是同理的，只是把加1，换成了减1；
计算口诀： 先-1，后使用

int a = 10;
int b = --a; //--的操作数是a，是放在a的前⾯的，就是前置--
printf("a=%d b=%d\n",a , b); //输出的结果是：9 9

后置–
同理后置–类似于后置++，只是把加一换成了减一
计算口诀：先使用，后-1

int a = 10;
int b = a--; //--的操作数是a，是放在a的后⾯的，就是后置--
printf("a=%d b=%d\n",a , b); //输出的结果是：9 10

3.取地址操作符 & 与解引用操作符 *

（1）取地址操作符

我们想要知道某变量的地址时，就可以使用 & 得到。
看一段代码

#include <stdio.h>
int main()
{
	int a=1;
	printf("%p,"&a);
	return 0;
}

a变量创建的本质是：
在内存上开辟空间，向内存申请4个字节的空间，存放数据1，且每个字节都有地址,&a取出来的是a所占四个字节中地址较小的字节的地址。
整型变量占了4个字节，现在我们只知道第一个字节的地址，但是我们可以顺着下去找出该变量其他字节的地址，然后访问到这些地址的数据

（2）指针变量

指针变量是用来存储地址的，因为地址也是一个数值，后期可能要经常使用。

#include <stdio.h>
int main()
{
	int a=1;
	int*pa=&a;
	return 0;
}

取出a的地址存储到指针变量pa中，单看 int* pa=&a，*说明 pa 是指针变量int 说明 pa 指向的是整型类型对象，也就是a的数据类型，int*是pa的数据类型。

（3）解引用操作符

解引用操作符 * 可以通过指针变量存储的地址找到地址指向的对象。

#include <stdio.h>
int main()
{
	int a=1;
	int*pa=&a;
	*pa=0;
	return 0;
}

*pa=0;这里就用了解引用操作符，通过pa指针变量存储的地址找到了a，所以 *pa就是a,也就是将0赋值给了a。学习这个之后，我们之后就可以灵活地运用解引用操作符解决很多问题了。

4.正负号操作符+、-

这里的+是正号，-是负号，都是单目操作符。
运算符 + 对正负值没有影响，是一个完全可以省略的运算符，但是写了也不会报错。

int a = +10; 等价于 int a = 10; 

运算符- 用来改变一个值的正负号，负数的前面加上 - 就会得到正数，正数的前⾯加上 - 会得到负数。

int a = 10; 
int b = -a;
int c = -10;
printf("b=%d c=%d\n", b, c); //这⾥的b和c都是-10
int a = -10;
int b = -a;
printf("b=%d\n", b); //这⾥的b是10

5.sizeof操作符

sizeof 是一个关键字，也是操作符，专门是用来计算sizeof的操作数的类型长度的，单位是字节。
sizeof 操作符的操作数可以是类型，也可以是变量或者表达式。

sizeof( 类型 )
sizeof 表达式

sizeof 的操作数如果不是类型，是表达式的时候，可以省略掉后边的括号的。
sizeof 后边的表达式是不真实参与运算的，根据表达式的类型来得出大小。
sizeof 的计算结果是 size_t 类型的。

📌 sizeof 运算符的返回值，C语⾔只规定是无符号整数，并没有规定具体的类型，而是留给系统自己去决定， sizeof 到底返回什么类型。不同的系统中，返回值的类型有可能是unsigned int ，也有可能是 unsigned long ，甚⾄是 unsigned long long ，对应的 printf() 占位符分别是 %u 、 %lu 和 %llu 。这样不利于程序的可移植性。C语言提供了一个解决方法，创造了一个类型别名 size_t ，用来统一表示 sizeof 的返回值类型。对应当前系统的 sizeof 的返回值类型，可能是 unsigned int ，也可能是unsigned long long 。

比如：

#include <stdio.h>
int main()
{
int a = 10;
printf("%zd\n", sizeof(a));
printf("%zd\n", sizeof a); //a是变量的名字，可以省略掉sizeof后边的()
printf("%zd\n", sizeof(int));
printf("%zd\n", sizeof(3 + 3.5));
return 0;
}

数据类型长度

#include <stdio.h>
int main()
{
printf("%zd ", sizeof(char));
printf("%zd ", sizeof(_Bool));
printf("%zd ", sizeof(short));
printf("%zd ", sizeof(int));
printf("%zd ", sizeof(long));
printf("%zd ", sizeof(long long));
printf("%zd ", sizeof(float));
printf("%zd ", sizeof(double));
printf("%zd ", sizeof(long double));
return 0;
}

在VS2022X64配置下的输出：

1 1 2 4 4 8 4 8 8

sizeof中表达式不计算

//测试：sizeof中表达式不计算
#include <stdio.h>
int main()
{
short s = 2;
int b = 10;
printf("%d\n", sizeof(s = b+1));
printf("s = %d\n", s);
return 0;
}

sizeof 在代码进行编译的时候，就根据表达式的类型确定了大小，而表达式的执行却要在程序运行期间才能执行，在编译期间已经将sizeof处理掉了，所以在运行期间就不会执行表达式了。

6.强制类型转换（类型）

在操作符中还有一种特殊的操作符是强制类型转换，语法形式很简单，形式如下：

(类型)

请看代码：

int a = 3.14;
//a是int类型, 3.14是double类型，两边的类型不⼀致，编译器会报警告

为了消除这个警告，我们可以使用强制类型转换：

int a = (int)3.14; //意思是将3.14强制类型转换为int类型，这种强制类型转换只取整数部分 

俗话说，强扭的瓜不甜，我们使用强制类型转换都是万不得已的时候使用，如果不需要强制类型转化就能实现代码，这样自然更好。
关系操作符，逻辑操作符和条件操作符在我这篇博客里面有讲到，不会的可以点击链接去学习哟：https://blog.csdn.net/weixin_66058866/article/details/134749600?spm=1001.2014.3001.5501。

---

今天先分享到这里，看完别忘了给博主一键三连哟！创作不易，谢谢宝子们❤️!