C语言基础之位运算（一）
C语言基础之位运算（二）
C语言基础之位运算（三）

1. 位运算

若要置1用位或 |；若要清零用位与 &；若要取反用位异或 ^；位取反~ 和左位移<<、右位移>>用来构建特定二进制数；

1. 1、给定一个整型数a，设置a的bit3为1，保证其它位不变

a = a | (1<<3); 或者 a |= (1<<3); // 1为十进制

1. 2、给定一个整型数，设置a的bit3~bit7为1，保持其它位不变

a = a | (0b11111<<3); 或者 a |= (0x1f<<3); // 0b：二进制前缀；0x：十六进制前缀；

1. 3、给定一个整型数a，清零a的bit15，保证其它位不变

a = a & (~(1<<15)); 或者 a & = ~(0x1<<15);// 1为十进制；0x1为16进制

1. 4、给定一个整型数a，清零a的bit15~bit23，保持其它位不变

a = a & (~(0x1ff<<15)); 或者 a &= (~(0x1ff<<15));

1. 5、给定一个整型数a，取值a的bit3~bit8

a &= (0x3f<<3); // 清零bit3-bit8外的其他位，只保留需要位上的数
a >>= 3; // 右移到最低位进行读取

1. 6、给寄存器中的bit4～bit7取反，其它位不变

a ^= (0xFF << 4);

1. 7、给寄存器中bit7~bit17赋值十进制937，其它位不受影响

⚠️注意：
1、不能影响其他位；
2、将bit7~bit17直接清零覆盖；
步骤：
a &= (~(0x7ff<<7)); // 先将bit7~bit17清零，其他位不变
a |= (937<<7); // 把十进制数937写入bit7~bit17 ，其他位不变

1. 8、给寄存器中bit7_{bit17、bit21}bit25分别赋值十进制937、17，其它位不受影响

方法一：
// -- bit7~bit17赋值937 --
a &= ~(0x7ff<<7); // 清零bit7~bit17
a |= (937<<7); // 将十进制数937写入bit7~bit17

// -- bit21~bit25的赋值17 --
a &= ~(0x1f<<21); // 清零bit21~bit25
a |= 17<<21; // 将十进制数937写入bit21~bit25

方法二：
a &= ~((0x7ff<<7) | (0x1f<<21))；// 清零bit7-bit17，bit21-bit25
a |= (937<<7) | (17<<21)；// 算出937和17以及其所对应的位，并写入

1. 9、将寄存器中bit7~bit17的值加17，其它位不受影响

tmp = a & (0x3ff<<7); // 先读出原来bit7~bit17的值
tmp >>= 7; // 右移到最低位并读出原来的数
tmp += 17; // 给读取出的值 + 17
a &= ~(0x7ff<<7); // 将bit7~bit17清零
a |= tmp; // 最后将加值计算后的结果tmp，写入bit7~bit17

1. 10、给寄存器的bit7_{bit17赋值937，同时bit21}bit25的值加17

// -- bit7~bit17赋值937 --
a &= ~(0x7ff<<7); // 清零bit7~bit17
a |= (937<<7); // 将十进制数937写入bit7~bit17

// -- bit21~bit25的值加17 --
tmp = a & (0x1f<<21); // 先读出原来bit21~bit25的值
tmp >>= 21; // 右移到最低位并读出原来的数
tmp += 17; // 给读取出的值 + 17
a &= ~(0x1f<<21); // 将bit21~bit25清零
a |= tmp; // 最后将加值计算后的结果tmp，写入bit21~bit25

1. 11、打印二进制数

#include <stdio.h>

/* 以32位二进制格式打印输出data的值，高位为0不清除 */
int print_bin(unsigned int data)
{
    int len = sizeof(data)*8;
    if (0 == len)
    {
        printf("0");
        printf("\n");
        return 0;
    }

    for(--len; len>=0; len--)
    {
        printf("%d", (data&(1<<len)) != 0);
        if (!(len%4))
        {
            printf(" ");    // 没隔4位打印1个空格
        }
    }
    printf("\n");           // 最后打印换行符

    return 0;
}

int main(char argc, char **argv)
{
    // 把一个寄存器值的bit4～bit7取反，其它位不变
    unsigned int a = 0x123d0c37;
    print_bin(a);                   // 0001 0010 0011 1101 0000 1100 0011 0111 
    a ^= (0xFF << 4);
    print_bin(a);                   // 0001 0010 0011 1101 0000 0011 1100 0111 

    // 把一个寄存器值的bit4～bit7置1，其它位不变
    unsigned int b = 0x123d0c37;    
    print_bin(b);                   // 0001 0010 0011 1101 0000 1100 0011 0111 
    b |= (0xFF << 4);
    print_bin(b);                   // 0001 0010 0011 1101 0000 1111 1111 0111          

    // 把一个寄存器值的bit4～bit7清0，其它位不变
    unsigned int c = 0x123d0c37;    
    print_bin(c);                   // 0001 0010 0011 1101 0000 1100 0011 0111 
    c &= ~(0xFF << 4);
    print_bin(c);                   // 0001 0010 0011 1101 0000 0000 0000 0111 

    return 0;
}

2. 宏定义位运算

2.1、用宏定义将32位数x的第n位置位，n的取值范围为[1, 32]，即第一位为bit0，U：unsigned int 无符号整型。

#define SET_BIT_N(x, n) (x | (1U<<(n-1)))

2.2、用宏定义将32位数x的第n位清零复位，n的取值范围为[1, 32]。

#define RESET_BIT_N(x, n) (x & ~(1U<<(n-1)))

2.3、用宏定义将32位数x的第n位到第m位置位。

#define SET_BIT_N_M(x, n, m) (x | (((~0U) >> (32-(m-n+1)))<<(n-1)))
#define SET_BIT_N_M(x, n, m) (x | ₍0U<<(m-n+1))<<(n-1))

2.3.1、分析

假如n=3，m=6，题目就是要把bit2到bit5置位，我们需要一个算式来得到（m-n+1）个1。

1、先得到32位1：~0U； //~按位取反得到32位1，若直接1U那么就只有bit0位1

2、将上步骤得到的二进制数右移 y 位或左移（m-n+1）位后按位取反，就得到最低位（m-n+1）个1，即(~0U >> (32-(m-n+1))) 或 ₍0U<<(m-n+1))；// y +（m-n+1）= 32

3、得到宏定义结果：
#define SET_BIT_N_M(x, n, m) (x | (((~0U) >> (32-(m-n+1)))<<(n-1)))
#define SET_BIT_N_M(x, n, m) (x | ₍0U<<(m-n+1))<<(n-1))

2.3.2、总结

得到(m-n+1)个1的二进制数的两种方式：
1、32位的1先左移(m-n+1)位，那么低(m-n+1)位位0，高(32-(m-n+1))位为1，再将其按位取反，就得到低(m-n+1)位为1，高(32-(m-n+1))位为0，即：₍0U << (m-n+1)) ；

2、有(m-n+1)个1，那么就有32-(m-n+1)个0，将32位的1先右移32-(m-n+1)， 那么高32-(m-n+1)位为0，低(m-n+1)位为1，即：(~0U) >> (32-(m-n+1))；

2.4、用宏定义将32位数x的第n位到第m位值取出。

#define GET_BITS(x, n, m) (x & ₍0U << (m-n+1)) << (n-1)) >> (n-1))

2.4.1分析

1、先将x的bit(n-1)-bit(m-1)不变，其余位清零；

1.1、首先要得到第n位到第m位的长度，即(m-n+1)个1的二进制数： ₍0U << (m-n+1)) ；

1.2、将得到的二进制数左移(n-1)： ₍0U << (m-n+1)) << (n-1) ；

1.3、x和左移后的数位与，将bit(n-1)-bit(m-1)外的其他位清零： x & ₍0U << (m-n+1)) << (n-1) ；

2、右位移取值

位与后的数右移(n-1)，即可取出第n-m间的值：(x & ₍0U << (m-n+1)) << (n-1)) >> (n-1) ；

3、宏定义结果

#define GET_BITS(x, n, m) (x & ₍0U << (m-n+1)) << (n-1)) >> (n-1))

2.4.2、总结

其实就是在置位的基础上，右移取值。

写在最后

位运算符——运算符优先级
算法篇：位运算