C语言：操作符（1）

1. 操作符分类

算数操作符：+ 、- 、* 、/ 、%

移位操作符：>> 、<<

位操作符：& 、| 、^

赋值操作符：= 、+= 、-= 、*= 、/= 、%= 、<<= 、>>= 、&= 、|= 、^=

单目操作符：! 、++ 、-- 、& 、* 、+ 、- 、~ 、sizeof 、（类型）

关系操作符：> 、>= 、< 、<= 、== 、!=

逻辑操作符：&& 、||

条件操作符： ？ ：

逗号表达式：,

下标引用：[ ]

函数调用：( )

结构成员访问：.  、->

我们已经接触过算术操作符、赋值操作符、逻辑操作符、条件操作符和部分的单目操作符，现在学习另一部分，操作符中有一些操作符和二进制有关系，我们先了解一下二进制的和进制转换的知识。

2. 二进制与进制转换

我们知道常见的进制有 2 进制、 8 进制、 10 进制、 16 进制 ，那这些进制是什么意思呢？

其实2进制、8进制、10进制、16进制是数值的不同表示形式而已。

比如：数值15的各种进制的表示形式：

二进制：1111
八进制：17
十进制：15
十六进制：F

//16进制的数值之前写：0x 
//8进制的数值之前写:0

这里我们重点介绍一下二进制：

拿我们生活中常见的十进制举例：

十进制满10进1，每一位的数字都有0~9组成

那么将规律类推到二进制中：

二进制中满2进1，每一位数字由0~1组成

2.1 二进制与十进制之间的转换

以十进制为例，十进制的每一位数字都有权重，10 进制的数字从右向左是个位、十位、百位...，分别每一位的权重是10的0次 ,10的1次,10的2次…

那么与之类似，2进制的每一位的权重，从右向左是: 2的0次,2的1次,2的2次...

因此二进制中的 1101 转换为十进制就是：

1 * 2^(0) + 1* 2^(1) + 0* 2^(2) + 1 * 2^(3) = 11

那么，十进制的数字如何转换为二进制数字呢？

这时，我们就需要使用取余法，让十进制的数字不断除以2并保留余数，直到商为零，最后将取余得到的各位倒序排序。

例如，将十进制数字的125转换为二进制数字就是：

125 / 2 = 62……1
62 / 2 = 31……0
31 / 2 = 15……1
15 / 2 = 7……1
7 / 2 = 3……1
3 / 2 = 1……1
1 / 2 = 0……1
//倒叙排序
1111101

将得到结果进行验算，发现结果恰好是125。

2.2 二进制转换为八进制与十六进制

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

如：2进制的01101011，换成8进制：0153，0开头的数字，会被当做8进制。

二进制： 01 101 011
八进制： 1   5   3

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

如：2进制的01101011，换成16进制：0x6b，16进制表示的时候前面加0x

二进制： 0110 1011
十六进制： 6    b

3. 原码、反码、补码

整数的2进制表示方法有三种，即原码、反码和补码

有符号整数的三种表示方法均有符号位和数值位两部分，2进制序列中，最高位的1位是被当做符号 位，剩余的都是数值位。

符号位都是用0表示“正”，用1表示“负”。

正整数的原、反、补码都相同。 负整数的三种表示方法各不相同。

原码：直接将数值按照正负数的形式翻译成二进制得到的就是原码。

反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。

补码：反码+1就得到补码。

补码得到原码也是可以使用：取反，+1的操作。

对于整形来说：数据存放内存中其实存放的是补码

这是为什么呢？

在计算机系统中，数值⼀律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统⼀处理；同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

4. 移位操作符

<< 左移操作符

>> 右移操作符

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

4.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;
}

//输出结果

n = 20
num = 10

//左移前
00000000000000000000000000001010 = 10
//左移后
00000000000000000000000000010100 = 20

我们发现，左移操作后，数值变为了原来的2倍，正好对应每一位向左移动一位，每一位权重提升一次。

4.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;
}

//输出结果

n = 5
num = 10

//右移前
00000000000000000000000000001010 = 10
//右移后
00000000000000000000000000000101 = 10

与左移操作类似，右移操作后，数值变为了原来的一半，正好对应每一位向右移动一位，每一位权重降低一次。

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

int num = 10;
num>>-1;//程序报错

5. 位操作符

位操作符有：

      
按位与  &
按位或  |
按位异或  ^
按位取反  ~
 

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

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

//输出结果
5
-3
-8
-1

解析：

10000000000000000000000000000011 = -3 原码
11111111111111111111111111111100      反码
11111111111111111111111111111101      补码
00000000000000000000000000000101 = 5  正数补码与原码相同
00000000000000000000000000000000 = 0
按位与操作：当两个二进制数对应位都为1时，结果位才为1，否则为0 
          11111111111111111111111111111101 = -3
          00000000000000000000000000000101 = 5
-3 & 5  = 00000000000000000000000000000101 = 5

按位或操作：当两个二进制数对应位至少有一个为1时，结果为1，否则为0
          11111111111111111111111111111101 = -3
          00000000000000000000000000000101 = 5
-3 | 5  = 11111111111111111111111111111101      补码
          00000000000000000000000000000010      反码
          10000000000000000000000000000011 = -3 原码
按位异或操作：当两个二进制数对应位不同时，结果位为1；相同为1
          11111111111111111111111111111101 = -3
          00000000000000000000000000000101 = 5
-3 ^ 5  = 11111111111111111111111111111000      补码
          10000000000000000000000000000111      反码
          10000000000000000000000000001000 = -8 原码
按位取反操作：二进制数字每一位为1时结果位为0，否则为1
 0 = 00000000000000000000000000000000 
~0 = 11111111111111111111111111111111      补码
     10000000000000000000000000000000      反码
     10000000000000000000000000000001 = -1 原码

计算机计算时使用补码，输出时通过原码还原出补码对应的数值。

这里引入一道有意思的题目：

在不创建第三个临时变量的情况下交换两个变量的值。

正常情况下我们会写出下面的代码实现题目要求：

#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);
    return 0;
}

交换前：a = 1 b = 2
交换后：a = 2 b = 1

 

 将 a + b赋值给a，然后将a - b赋值给b，此时b中就是原本 a 的值，最后将a - b赋值给 a ，此时，a 中就是原本 b 的值，实现了两个变量的值的交换。

但是这个代码的有一点缺陷就是：int 类型能表示的值是有范围的，如果两个变量的值过大，在第一步将 a + b赋值给 a 的操作中就有可能导致数值超出范围，那也没有更好的方法呢? 

我们回归一下上面的位操作符中的按位异或操作符 ^ ，由于按位异或的执行逻辑是两个二进制对应位相同时为0，不同为1，那么， a ^ a的值肯定就是0了，那a ^ 0的值呢？0的二进制每一位都为0，也就是说，位相同即都为0是为0；位不同即为1时，结果为1。那么相当于没有改变原数值，结果为a，知道了这个规律，我们就可以通过下面的代码实现题目要求：

#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);
    return 0;
}

交换前：a = 1 b = 2
交换后：a = 2 b = 1

 将a ^ b赋值给a，此时结果不重要；接着，将 a ^ b赋值给b，那就是 a ^ b ^ a，因为按位异或运算的顺序是不会影响结果的，所以就相当于 a ^ b ^ b = 0 ^ a = a；最后将 a ^ b赋值给a，即 a ^ b ^ a = a ^ a ^ b = 0 ^ b = b，实现两个变量的值的交换。

这样就不需要担心变量的值可能超出范围。

不过正常情况下，通过创建变量来实现两个变量值的交换效率更快，并且代码的可读性也更高。

5.1 求一个二进制数中1的个数

题目：

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

看到题目，我们很容易就联想到上面十进制转换二进制的方法，用代码实现就是如下形式：

#include <stdio.h>

int main()
{
    int a,count = 0;
    scanf("%d",&a);
    int n = a;
    while(n)
    {
        if(n % 2 == 1)
            count++;
        n = n / 2;
    }
    printf("%d的二进制储存形式中有%d个1",a,count);
    return 0;
}

但是这个代码有个缺陷，那就是无法处理负数。

所以有没有其他方法呢？

我们回想起上面的左移操作符，如果我们让数字的二进制位每左移一次让其原数按位与运算，如果结果不为0，就记1；否则为0。用代码实现就是如下形式：

#include <stdio.h>

int main()
{
    int a,i,count = 0;
    scanf("%d",&a);
    for(i = 0;i < 32;i++)
    {
        if( a & (a << i))
            count++;
    }
    printf("%d的二进制储存形式中有%d个1",a,count);
    return 0;
}

这个代码就是兼顾了处理负数的情况，但是要想处理一个数就必定会循环32次，有没有方法减少循环次数呢？

#include <stdio.h>

int main()
{
    int a,count = 0;
    scanf("%d",&a);
    int n = a;
    while(n)
    {
        count++;
        n = n & (n - 1);
    }
    printf("%d的二进制储存形式中有%d个1",a,count);
    return 0;
}

让n值作为循环条件，因为n不为0时，二进制形式至少有一个1；将n & (n - 1)赋值给n。这样，让n值减去1，如果此位为1，就只会产生一个零；否则就向前借数，中间部分的1与原本的0在按位与操作后就全部变为0；接着循环此操作，直到n为0，说明n中没有1了，循环结束。每一次循环都能消去二进制中的一个1，提高了循环效率。

5.2 让二进制指定位变为1或0

题目：

编写代码将13⼆进制序列的第5位修改为1，然后再改回0。

很明显，这里需要用到位操作符。那么应该使用哪一种呢？

很明显，如果是将0改为1，用&是不可能实现的；~ 会将全部位改变，不能使用。那么就剩下 | 和 ^ 了。但是 ^ 是在相同时改为0，不同则为1，那么就有可能出现错改的情况。现在，我们就剩下 |了，那现在的问题是，让什么数与指定值进行按位或操作呢？

既然是将0改为1，那需要修改的那一位上我们需要是1，其他位不能修改，需要为0；那需要我们在修改时，根据位数来计算值再使用？不需要，我们只需要对1使用<<就可以实现要求。让1移动到指定位，其余部分都用0补充。

相应的，要修改回0改怎么操作？在保证不修改错误的情况下让1变为0，那我们就只能选择&，那使用&的话，将1修改位0需要对应位为0；不能影响其他位，所以剩下所有位需要为1。我们发现，这个形式不正好与我们进行了左移操作后的1相反么，只需要使用 ~ 就可以实现。

因此，我们就可以得到如下代码：

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

a = 29
a = 13

13 = 00000000000000000000000000001101
29 = 00000000000000000000000000011101

可以看到，结果符合我们预期。