21. c语言将指定位置0，置1，翻转，检查及多位同时操作

在 C 语言中，可以使用位操作对指定的位进行清 0（将指定的位设置为 0）或置 1（将指定的位设置为 1）。这些操作一般通过按位与（&）、按位或（|）、**按位异或（^）**等运算符来实现。

1. 清 0 指定位

清 0 是指将某些位设置为 0，保持其他位不变。通常使用按位与（&）配合掩码来实现。

示例：清除第 n 位为 0

假设你要清除整数 x 的第 n 位，可以使用以下方法：

x = x & ~(1 << n);

• 1 << n：生成一个只有第 n 位是 1，其他位全为 0 的掩码。
• ~(1 << n)：对掩码进行按位取反，得到一个只有第 n 位是 0，其他位是 1 的掩码。
• x & ~(1 << n)：将 x 的第 n 位清零，其他位保持不变。

示例代码：

#include <stdio.h>
// 自定义函数，打印整数的二进制表示，跳过前导0
void print_binary(int num) {
    int size = sizeof(num) * 8;  // 获取整数类型的总位数
    int started = 0;  // 标记是否已经遇到第一个1
    printf("0b");
    for (int i = size - 1; i >= 0; i--) {
        int bit = (num >> i) & 1;  // 通过位移提取每一位
        
        if (bit == 1) {
            started = 1;  // 遇到第一个1时，标记开始打印
        }
        
        if (started) {    // 只在遇到第一个1后开始打印
            printf("%d", bit);
        }
    }

    if (!started) {  // 如果没有遇到1，说明是0
        printf("0");
    }

    printf("\n");  // 打印完后换行
}
int main() {
    int x = 0b1111;  // 原始数据，二进制为 1111
    int n = 2;       // 清除第 2 位
    x = x & ~(1 << n);
    print_binary(x);    // 输出：1011（二进制） 即 11
    return 0;
}

2. 置 1 指定位

置 1 是指将某些位设置为 1，保持其他位不变。通常使用**按位或（|）**配合掩码来实现。

示例：设置第 n 位为 1

假设你要将整数 x 的第 n 位设置为 1，可以使用以下方法：

x = x | (1 << n);

• 1 << n：生成一个只有第 n 位是 1，其他位全为 0 的掩码。
• x | (1 << n)：将 x 的第 n 位设置为 1，其他位保持不变。

示例代码：

#include <stdio.h>
// 自定义函数，打印整数的二进制表示，跳过前导0
void print_binary(int num) {
    int size = sizeof(num) * 8;  // 获取整数类型的总位数
    int started = 0;  // 标记是否已经遇到第一个1
    printf("0b");
    for (int i = size - 1; i >= 0; i--) {
        int bit = (num >> i) & 1;  // 通过位移提取每一位
        
        if (bit == 1) {
            started = 1;  // 遇到第一个1时，标记开始打印
        }
        
        if (started) {    // 只在遇到第一个1后开始打印
            printf("%d", bit);
        }
    }

    if (!started) {  // 如果没有遇到1，说明是0
        printf("0");
    }

    printf("\n");  // 打印完后换行
}
int main() {
    int x = 0b1011;  // 原始数据，二进制为 1011
    int n = 2;       // 设置第 2 位
    x = x | (1 << n);
    print_binary(x);   // 输出：1111（二进制）
    return 0;
}

3. 翻转指定的位

翻转位是将某些位的值从 0 变为 1，或从 1 变为 0，可以通过**按位异或（^）**配合掩码来实现。

示例：翻转第 n 位

假设你要翻转整数 x 的第 n 位，可以使用以下方法：

x = x ^ (1 << n);

• 1 << n：生成一个只有第 n 位是 1，其他位全为 0 的掩码。
• x ^ (1 << n)：将 x 的第 n 位进行翻转，其他位保持不变。

示例代码：

#include <stdio.h>
// 自定义函数，打印整数的二进制表示，跳过前导0
void print_binary(int num) {
    int size = sizeof(num) * 8;  // 获取整数类型的总位数
    int started = 0;  // 标记是否已经遇到第一个1
    printf("0b");
    for (int i = size - 1; i >= 0; i--) {
        int bit = (num >> i) & 1;  // 通过位移提取每一位
        
        if (bit == 1) {
            started = 1;  // 遇到第一个1时，标记开始打印
        }
        
        if (started) {    // 只在遇到第一个1后开始打印
            printf("%d", bit);
        }
    }

    if (!started) {  // 如果没有遇到1，说明是0
        printf("0");
    }

    printf("\n");  // 打印完后换行
}
int main() {
    int x = 0b1011;  // 原始数据，二进制为 1011
    int n = 1;       // 翻转第 1 位
    x = x ^ (1 << n);
    print_binary(x);    // 输出：1001（二进制） 即 9
    return 0;
}

4. 检查某个位是否为 1

检查位 是判断某个位是否为 1，可以通过**按位与（&）**操作来实现。

示例：检查第 n 位是否为 1

假设你要检查整数 x 的第 n 位是否为 1，可以使用以下方法：

if (x & (1 << n)) {
    // 第 n 位为 1
} else {
    // 第 n 位为 0
}

示例代码：

#include <stdio.h>

int main() {
    int x = 0b1011;  // 原始数据，二进制为 1011
    int n = 2;       // 检查第 2 位
    if (x & (1 << n)) {
        printf("Bit %d is 1\n", n);
    } else {
        printf("Bit %d is 0\n", n);//输出：Bit 2 is 0，因为从右到左分别为第0、1、2、3位
    }
    return 0;
}

5. 将特定位置 0

可以通过按位与来将某些位清零，同时保持其他位不变。

示例：清除最后 4 位

要清除整数 x 的最后 4 位，可以使用以下方法：

x = x & ~0xF;

• 0xF 是十六进制，表示最后 4 位全为 1（即 1111）。
• ~0xF 是将最后 4 位取反，得到 11110000。
• x & ~0xF 是将 x 的最后 4 位清零，其他位不变。

示例代码：

#include <stdio.h>

int main() {
    int x = 0xABCD;  // 原始数据，十六进制 ABCD，二进制 1010101111001101
    x = x & ~0xF;    // 清除最后 4 位
    printf("Result after clearing last 4 bits: %X\n", x);  // 输出：ABC0
    return 0;
}

类似的操作

• 提取特定位：使用位掩码和位移操作提取某些位的值。

  int result = (x >> n) & 1;  // 提取 x 的第 n 位
  

• 将多个位设置为 1：可以通过位掩码一次性设置多个位。

  x = x | 0b1110;  // 将最后三位设置为 1
  

• 将多个位清 0：通过位掩码一次性将多个位清零。

  x = x & ~0b1110;  // 将最后三位清 0
  

总结

• 清 0 指定位：通过 x = x & ~(1 << n)。
• 置 1 指定位：通过 x = x | (1 << n)。
• 翻转位：通过 x = x ^ (1 << n)。
• 检查位：通过 x & (1 << n) 来检测某位是否为 1。
• 掩码操作：用于操作和处理特定位，常用于嵌入式编程、设备驱动开发等。