C语言之所以非常灵活,很大一部分原因在于其具有丰富的操作符,甚至可以直接操作到二进制的位。
1. 二进制介绍
我们经常能听到2进制、8进制、10进制、16进制这样的讲法,那是什么意思呢?
其实2进制、8进制、10进制、16进制只是同一个数据的不同表达形式而已。而我们重点讲解2进制!
首先我们还是从10进制讲起,它也是我们生活中经常使用的:
1、10进制中满10进1。
2、10进制的数字每⼀位都是0~9的数字组成。
其实二进制也是一样的:
1、2进制中满2进1。
2、2进制的数字每⼀位都是0~1的数字组成。
例如:1101就是⼆进制的数字!
1.1 2进制转10进制的规则
10进制的123表示的值是一百二十三,为什么是这个值呢?
其实10进制的每一位是权重的,10进制的数字从右向左是个位、十位、百位…,分别每⼀位的权重是
1
0
0
、
10^{0}、
100、
1
0
1
10^{1}
101、
1
0
2
10^{2}
102…如下图所示:
![](https://i-blog.csdnimg.cn/blog_migrate/7dbbda999bbdc22d114cb99ffe622316.jpeg)
2进制和10进制是类似的,只不过2进制的每⼀位的权重从10变为了2,从右向左是: 2 0 2^{0} 20, 2 1 2^{1} 21, 2 2 2^{2} 22…如下图所示:
![](https://i-blog.csdnimg.cn/blog_migrate/a69ef1eb6670aaaa26f0295ea5b4003e.jpeg)
总结:2进制转10进制采用的是乘法: 2 0 2^{0} 20+ 2 1 2^{1} 21+ 2 3 2^{3} 23+ 2 4 2^{4} 24+…
1.2 10进制转2进制的规则
![](https://i-blog.csdnimg.cn/blog_migrate/527d55b08de379151a196fd97a05a0c7.png)
总结:10进制转2进制采用的是除法:
123/2=61…1;
62/2=31…0;
31/2=15…1;
…
把余数倒着写上去!
1.3 2进制转8进制的规则
8进制的数字每⼀位是0~7的数字,各自写成2进制,最多有3个2进制位就足够了,比如7的二进制是111,所以在2进制转8进制数的时候,从2进制序列中右边低位开始向左每3个2进制位会换算一个8进制位,剩余不够3个2进制位的直接换算。
例如:2进制的01101011,换成8进制:0153,0开头的数字,会被当做8进制。
![](https://i-blog.csdnimg.cn/blog_migrate/5e678e1ab78a49f6341f0aafe7fbc83f.png)
1.4 2进制转16进制的规则
16进制数字的每⼀位是0~9,a~f(10~15)的数字,各⾃写成2进制,最多有4个2进制位就足够了,比如 f 的⼆进制是1111,所以在2进制转16进制数的时候,从2进制序列中右边低位开始向左每4个2进制位会换算⼀个16进制位,剩余不够4个⼆进制位的直接换算。如:2进制的01101011,换成16进制:0x6b,16进制表示的时候前面要加上0x。
![](https://i-blog.csdnimg.cn/blog_migrate/4dbeb303e3b156bf0f6c165feae2faa3.png)
2. 原码、反码、补码
整数的2进制表示方法有三种,即原码、反码和补码。
三种表示方法均有符号位和数值位两部分,符号位用0表示“正”,用1表示“负”。数值位最高位被当做符号位,其余的都是数值位。
正整数的原码、反码、补码都相同。
负整数的三种表示方法各不相同。
负整数原码:直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。
负整数反码:原码的符号位不变,其他位依次按位取反就可以得到反码。
负整数补码:反码+1就能得到补码。
例如:5 -5
Int a=5;(正整数三者相同)
//00000000000000000000000000000101—原码
//00000000000000000000000000000101—反码
//00000000000000000000000000000101—补码
Int b = -5;
//10000000000000000000000000000101—原码
//1111111111111111111111111111111010—反码(原码取反)
//1111111111111111111111111111111011—补码(反码+1)
对于整形来说:数据存放内存中其实存放的是补码!这是为什么呢?
其原因在于:
1.使用补码,可以将符号位和数值域统⼀处理;
2.加法和减法也可以统⼀处理(CPU只有加法器),此外,补码与原码相互转换,其运算过程是相同的,不需要额外的硬件电路。
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
//1-1
//1+(-1)
//00000000000000000000000000000001 1的原码
//10000000000000000000000000000001 -1的原码
//10000000000000000000000000000010 原码相加(-2)×
//00000000000000000000000000000001 1的补码
//11111111111111111111111111111110 -1的反码
//11111111111111111111111111111111 -1的补码
//00000000000000000000000000000000 补码相加,由于2进制逢2进1,所以第一位2会缺失最终全为0!!!
//而我们知道,1-1的结果就是0!补码运算结果正确
return 0;
}
负整数原码和补码之间的关系:
![](https://i-blog.csdnimg.cn/blog_migrate/9797b56f5ce51727971ee9bc899b53b4.png)
至于原码和补码是上面这种关系,其实俺也不知道😅。因为这是计算机的科学家得出探索出的规律,在以后的实践中我们只需要用就可以了。
3. 移位操作符
移位操作符有两种:<<、>>。
<<:左移操作符;
>>:右移操作符。
注意:操作符的操作数只能是整形,而且移动的是补码,打印的是原码!!!
3.1 左移操作符
移位规则:左边抛弃,右边补0;
![](https://i-blog.csdnimg.cn/blog_migrate/f4e354e3586c40106bbb4afead5a4fab.png)
结果:左移前num=0,左移后num=20。
但是负数就不一样了!
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = -10;
//原码:10000000000000000000000000001010
//反码:11111111111111111111111111110101
//补码:11111111111111111111111111110110
int b = a << 1;
//b的补码:11111111111111111111111111101100
//取反:10000000000000000000000000010011
//b的原码:10000000000000000000000000010100
printf("%d\n", b);
return 0;
}
由于负数的补码与原码不一致,需要先求得负数的补码,再进行移位操作,最后根据得到的补码找到对应的原码,然后进行打印。
结果:a= -10; b = -20
3.2 右移操作符
右移分两种:
1.逻辑右移:左边用0填充,右边丢弃。(简单粗暴,不合适)
2.算术右移:左边⽤原该值的符号位填充,右边丢弃。
![](https://i-blog.csdnimg.cn/blog_migrate/ff1251b071856c3d17d4380eb46b01f8.png)
可以看到,通过逻辑右移,num由负数变为了正数,太过于简单粗暴。
![](https://i-blog.csdnimg.cn/blog_migrate/9a729b18c1e88d919ffc28a2028435b4.png)
右移采用逻辑右移,还是算术右移,是不确定的,取决于编译器,但是大部分的编译器是采用算术右移的。
警告:不要移动负数位,因为这是没有定义的!
例如:
int num = 10;
num >> -1;
4. 位操作符:&、|、^、~
&——按位与
|——按位或
^——按位异或
注意:以上操作符的对象都是2进制,而且都是补码!
4.1 &——按位与操作符:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = 5;
int b = -6;
int c = a & b;//按位与—对应的二进制位,有0则为0,两个同时为1才是1
//00000000000000000000000000000101— 5的补码
//10000000000000000000000000000110
//11111111111111111111111111111001
//11111111111111111111111111111010— -6的补码
//00000000000000000000000000000101
//11111111111111111111111111111010
//00000000000000000000000000000000
printf("%d\n", c);
return 0;
}
运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/4549b9dbac49d045448010fcc6687c69.png)
4.2 |——按位或操作符:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = 5;
int b = -6;
int c = a | b;//按位或—对应的二进制位上有1则为1,两个同时为0才是0
//00000000000000000000000000000101— 5的补码
//10000000000000000000000000000110
//11111111111111111111111111111001
//11111111111111111111111111111010— -6的补码
//00000000000000000000000000000101
//11111111111111111111111111111010
//11111111111111111111111111111111
printf("%d\n", c);
return 0;
}
运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/26523281ca972e7486a3666a09b2e5a8.png)
4.3 ^——按位异或操作符
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = 5;
int b = -6;
int c = a ^ b;//按位异或—对应的二进制位上相同为0,相异则为0
//00000000000000000000000000000101— 5的补码
//10000000000000000000000000000110
//11111111111111111111111111111001
//11111111111111111111111111111010— -6的补码
//00000000000000000000000000000101
//11111111111111111111111111111010
//11111111111111111111111111111111
printf("%d\n", c);
return 0;
}
4.4 位操作符应用
4.4.1 不创建临时变量(第三个变量),实现两个数的交换
很多小伙伴看到这道题可能傻眼了,认为这是不可能的。事实上,用我们刚才学过的 ^ 操作符就能解决,具体操作且听我娓娓道来。
我们就拿a = 3,b = 5两个数来举例。
![](https://i-blog.csdnimg.cn/blog_migrate/5cdf58a3ce27cf032380fe5e6119b216.png)
a和b的二进制补码分别为011、101,通过a = a ^ b使得a的二进制补码变为110,b依然为101。
接着,通过b = a ^ b使得b的二进制补码变为011,此时我们可以看到b已经变为了3(正整数的原码、补码一致),在进行一次a^b,就能把a变为5。
代码实现如下:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = 3;
int b = 5;
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);
return 0;
}
运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/085ffa990435106fd1a19c92ee14e878.png)
在这里我用的是整数来举例说明,如果感兴趣的话,小伙伴们也可以用负整数来试试,结果肯定是正确的。
但是以上这种异或操作也存在一定局限性:
1.只能作用于整数的交换
2.代码的可读性差
3.代码执行的效率也低于使用第3个变量的方法
4.4.2 ⼀个整数存储在内存中的2进制中1的个数
在解决这个问题前,我们可以回想一下我们得到10进制每一位的操作方法:
通过不断的%10,/10操作,就能得到10进制整数的每一位,同样的我们可以将这个规律进行推广。如果我们对10进制数进行%2、/2操作,是不是就能得到它2进制中1的个数了呢?
在这里我们用15来举例:
显然,我们能够得到15的2进制中1的个数。
代码实现:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = 0;
int count = 0;
scanf("%d", &a);
while (a)
{
if (a % 2 == 1)
{
count++;
}
a = a / 2;
}
printf("%d\n", count);
return 0;
}
运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/238e808ce70d4942cf199b4a0e2fe527.png)
这段代码有没有问题呢?实际上,这段代码是有问题的,如果我们输入负数,那么结果就是错误的!
就比如说,我们拿-1来举例说明:
![](https://i-blog.csdnimg.cn/blog_migrate/5a43be4dc2e053f75d92dd9453627319.png)
我们都知道-1的二进制中有32个1,但是结果却显示0,这是为什么呢?
原因其实很简单,a = -1的时候,进入while循环里面,a % 2 != 1,count依然为0。a / 2 ==0,跳出while循环,打印结果就是count = 0。
既然找到了原因,那我们该如何解决呢?其实我们可以采用 >> 操作符解决问题。
修改后的代码:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = 0;
int i = 0;
int count = 0;
scanf("%d", &a);
for (i = 0; i < 32; i++)
{
if (((a >> i) & 1) == 1)
{
count++;
}
}
printf("%d\n", count);
return 0;
}
运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/59cb65328f3c042e1fb85027b502272f.png)
除了上面两种方法以外,还有一种方法,我也称它为终极方法,也是科技巨头Google的面试解题方法👍👍👍
在给出代码之前,还是按照惯例给大家介绍它的核心思想:
代码实现:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = 0;
int i = 0;
int count = 0;
scanf("%d", &a);
while (a)
{
a = a & (a - 1);
count++;
}
printf("%d\n", count);
return 0;
}
运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/cb331d9eee10075eb94d4e38eaab6f45.png)
4.4.3 n&(n-1)拓展
除了上述例子实例外,n&(n-1)也可以被用来判断一个数是否为 2 n 2^n 2n:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = 0;
int i = 0;
scanf("%d", &a);
if ((a&(a - 1)) == 0)
{
printf("yes\n");
}
else
{
printf("no\n");
}
return 0;
}
运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/f7be4aea4a0fcd8cff16a8cae3bec9a4.png)
4.5 ~—按位取反操作符(二进制是0的变成1,是1的变为0,连最前面的符号位也得取反)
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = 13;
//00000000000000000000000000001101
//00000000000000000000000000010000
//1<<4
a = a | (1 << 4);
printf("%d\n", a);
return 0;
}
运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/82e6c51a98ca53d0f0a7b09c88aa94f2.png)
把a改回来:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = 13;
//00000000000000000000000000001101
//00000000000000000000000000010000
//1<<4
a = a | (1 << 4);
printf("a=%d\n", a);
//00000000000000000000000000011101
//11111111111111111111111111101111
//00000000000000000000000000001101
a = a & ~(1 << 4);
printf("a=%d\n", a);
return 0;
}
运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/4083385e41f4835cdb014d5754adbd05.png)
5. 逗号表达式
逗号表达式,从左向右依次执行。整个表达式的结果是最后⼀个表达式的结果。
#define _CRT_SECURE_NO_WARNINGS
#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;
}
运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/7495fdb1ce3dca91309c8844ed30675d.png)
6. 下标访问[],函数调用()
6.1 下标引用操作符[]
操作数:一个数组名 + 一个索引值
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};//创建数组
printf("%d\n", arr[9]};//[]—下标引⽤操作符。
[]的两个操作数是arr和9
6.2 函数调用操作符()
接受⼀个或者多个操作数:第⼀个操作数是函数名,剩余的操作数就是传递给函数的参数。
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int add(int x, int y)
{
return x + y;
}
void test()
{
printf("haha\n");
}
int main()
{
int ret = add(2, 3);//()—函数调用操作符
//()的操作数:add,2,3
printf("%d\n", ret);
test();//()—函数调用操作符
return 0;
}
函数调用操作符最少有几个操作数呢?
很显然,最少保证1个操作数,这个操作数就是函数名!
7. 操作符的属性
C语言的操作符有2个重要的属性:优先级、结合性,这两个属性决定了表达式求值的计算顺序。
7.1 优先级
什么是优先级呢?
优先级指的是,如果⼀个表达式包含多个运算符,哪个运算符应该优先被执行。各种运算符的优先级是不⼀样的。
例如:
13 + 4 * 5;
在上面的示例中,表达式13 + 4 * 5 里面既有加法运算符( + ),又有乘法运算符( * )。由于乘法的优先级要高于加法,所以会先计算 4 * 5,而不是先计算 3 + 4。
7.2 结合性
如果两个运算符优先级相同,优先级没办法确定先计算哪个,这时候就看结合性了,即根据运算符是左结合,还是右结合,决定执行顺序。目前来说,大部分运算符是左结合(从左到右执行),少数运算符是右
结合(从右到左执行),比如赋值运算符( = )。
例如:
15 * 6 / 2;
上述示例中,* 和 / 的优先级相同,它们都是左结合运算符,所以要从左到右执行,先计算 5 * 6 ,再计算 6 / 2 。运算符的优先级顺序很多,下⾯是部分运算符的优先级顺序(按照优先级从高到低排列),大概记住这些操作符的优先级就行,其他的操作符在使用的时候查看后面的表格就行了。
1.圆括号( () )
2.自增运算符( ++ ),自减运算符( – )
3.⼀元运算符( + 和 - )
4.乘法( * ),除法( / )
5.加法( + ),减法( - )
6.关系运算符( < 、 > 等)
7.赋值运算符( = )
由于圆括号的优先级最高,因此可以用它来改变其他运算符的优先级。
其他运算符优先顺序表:
8. 表达式求值
表达式求值之前要进行类型转换,只有表达式中的值转换到适当的类型,才开始计算!
C语言中数值的类型转换有两种,分别是整形提升和算术转换。
8.1 整形提升
C语言中整型算术运算总是至少以缺省整型类型(int)的精度来进行的。
为了获得这个精度,表达式中的字符(char)和短整型操作数(short)在使用之前被转换为普通整型(int / unsigned int),这种转换称为整型提升。
8.1.1 为什么要进行整形提升?
表达式的整型运算要在CPU的相应运算器件内执⾏,CPU内整型运算器(ALU)的操作数的字节⻓度⼀ 般就是int的字节⻓度,同时也是CPU的通用寄存器的长度。 因此,即使两个char类型的相加,在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。 通用CPU(general-purpose CPU)是难以直接实现两个8比特字节直接相加运算(虽然机器指令中可能有这种字节相加指令)。所以,表达式中各种长度可能小于int长度的整型值,都必须先转换为 int或unsigned int,然后才能送⼊CPU去执行运算。
读完这段话,相信各位小伙伴都比较懵圈😂。没关系,下面我就以两个char类型的变量相加为例(char a,char b),来对上面这段话进行解释。
![](https://i-blog.csdnimg.cn/blog_migrate/cbf7617cfdbcf59bee60e87a4072e244.png)
上面这幅图就非常清晰地向我们解释了为什么要进行整形提升,说白了其目的就是为了保留数据的精度。两个char类型的数字相加,可能发生进位,导致数据丢失。而如果都转化成为int 类型的变量,假设放入char类型的变量,也只占8个bit位,即使相加发生进位,也只是溢出到前一位上,数据也不会丢。它的精度就可能保留了!
例如:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
char a = 5;
char b = 127;
char c = a + b;
printf("%d\n", c);
return 0;
}
运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/b06ea3df88798e1101eed5eaf1f52088.png)
至于为什么是-124,后面会进行解释,在这儿先卖个关子😋。
8.1.2 如何进行整形提升?
如何进行整数提升分为两种情况:有符号整数提升、无符号整数提升。
(一)有符号整数提升
有符号整数提升是按照变量的数据类型的符号位来提升的。
例如我们刚才所举的例子:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
char a = 5;
//5 — int — 32bit
//00000000000000000000000000000101
//00000101 — a(截断后存储到a中)
char b = 127;
//00000000000000000000000001111111
//01111111 — b(截断后存储到b中)
char c = a + b;//发生整形提升
//00000000000000000000000000000101 — a
//00000000000000000000000001111111 — b
//00000000000000000000000010000100 — a+b
//10000100 — c
printf("%d\n", c);//这里c还要提升
//11111111111111111111111110000100 — 补码
//10000000000000000000000001111011 — 反码
//10000000000000000000000001111100 — 原码
//-124
return 0;
}
(二)无符号整数提升
无符号整数提升用的比较少,而且方法也比较简单,直接在高位补0即可。
这里我就不再用加法举例了,直接用%d打印char类型的数值:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
unsigned char b = -1;
//10000001 — 原码
//11111110 — 反码
//11111111 — 补码
printf("%d\n", b);//整形提升,高位补0
//00000000000000000000000011111111 — 补码
//00000000000000000000000011111111 — 反码
//00000000000000000000000011111111 — 原码
//正数原码、反码和补码一样
//255
return 0;
}
运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/007fda81a9da9e398bb13ffab4cc6188.png)
8.2 算术转换
讲完整形提升,接下来我们再来讲一下算术转换。
按照惯例,我们先介绍算术转换的概念:如果某个操作的各个操作数属于不同的类型,除非其中⼀个操作数转换为另⼀个操作数的类型,否则操作就无法进行。而一种操作数转换为另一种操作数的过程就叫做算术转换。
既然我们操作数需要转换为另一种操作数,我们就不可避免地要面对转换的次序问题。下面的层次体系称为寻常算术转换。
如果某个操作数的类型在上面这个列表中排名靠后,那么首先要转换为另外⼀个操作数的类型后执行运算。
写到这儿,这期博客差不多就完成了,但是我还是想给大家介绍一下几个问题表达式,感兴趣的小伙伴可以接着往下看😊。
9. 问题表达式
9.1 表达式1
a*b + c*d + e*f
表达式1在计算的时候,由于 * 比 + 的优先级高,只能保证 * 的计算是比 + 早,但是优先级并不能决定第三个 * 比第⼀个 + 早执行。所以表达式1的计算机顺序就可能存在以下两种情况:
顺序1:
a*b
c*d
a*b + c*d
e*f
a*b + c*d + e*f
顺序2:
a*b
c*d
e*f
a*b + c*d
a*b + c*d + e*f
9.2 表达式2
c + --c;
同上,操作符的优先级只能决定⾃减 – 的运算在 + 的运算的前面,但是我们并没有办法得知 + 操作符的左操作数的获取在右操作数之前还是之后求值,所以结果是不可预测的,是有歧义的。
9.3 表达式3
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int i = 10;
i = i-- - --i * (i = -3) * i++ + ++i;
printf("i = %d\n", i);
return 0;
}
这段代码是《C和指针》这本书的作者测试的,这段代码同样存在歧义。具体有哪些歧义,感兴趣的小伙伴可以试着解答一下😁。
在各种编译器下运行,得到不同的结果如下:
![](https://i-blog.csdnimg.cn/blog_migrate/792d77540679d80458550d3c08335ffa.png)
总结:即使有了操作符的优先级和结合性,我们写出的表达式依然有可能不能通过操作符的属性确定唯⼀的。计算路径,那这个表达式就是存在潜在风险的,建议不要写出特别负责的表达式。