嵌入式知识点总结 C/C++ 专题提升(七)-位操作

针对于嵌入式软件杂乱的知识点总结起来，提供给读者学习复习对下述内容的强化。

目录

1.位操作基础

[2.如何求解整型数的二进制表示中1的个数 ?](#2.如何求解整型数的二进制表示中1的个数 ?)

3.如何求解二进制中0的个数

4.交换两个变量的值，不使用第三个变量。即a=3,b=5,交换之后a=5,b=3:

[5.给定一个整型变量a，写两段代码，第一个设置a的bit3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。](#5.给定一个整型变量a，写两段代码，第一个设置a的bit3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。)

---

1.位操作基础

位操作（Bitwise Operations）是直接对二进制位进行操作的一类运算，广泛应用于嵌入式开发、系统编程、算法设计等领域。以下是常用的位操作及其作用、示例。

按位与 (&)

将两个数的每个位进行与运算。

规则：1 & 1 = 1，其余为 0。

作用：用于清零某些位，提取特定位。

示例：清除一个数的低 4 位

int x = 0b11010101; // 213
int result = x & 0b11110000; // 清除低4位
printf("Result: 0x%x\n", result); // 输出: 0xd0

按位或 (|)

将两个数的每个位进行或运算。

规则：0 | 0 = 0，其余为 1。

作用：用于设置某些位为 1。

示例：设置某数的第 3 位为 1

int x = 0b11000001; // 193
int result = x | 0b00000100; // 设置第3位
printf("Result: 0x%x\n", result); // 输出: 0xc5

按位异或 (^)

将两个数的每个位进行异或运算。

规则：相同为 0，不同为 1。

作用：用于翻转特定位，或无进位加法。

示例：翻转某数的第 3 位

int x = 0b11000001; // 193
int result = x ^ 0b00000100; // 翻转第3位
printf("Result: 0x%x\n", result); // 输出: 0xc5

按位取反 (~)

将每个位取反，0 变 1，1 变 0。

作用：用于生成补码、求反值。

示例：取反某数

int x = 0b00001111; // 15
int result = ~x; // 取反
printf("Result: 0x%x\n", result); // 输出: 0xfffffff0 (补码表示)

左移 (<<)

将二进制位左移，低位补 0。

作用：快速乘以 2 的幂。

示例：将某数左移 2 位

int x = 5; // 0b0101
int result = x << 2; // 左移2位
printf("Result: %d\n", result); // 输出: 20

右移 (>>)

将二进制位右移，高位补符号位（算术右移）或 0（逻辑右移）。

作用：快速除以 2 的幂。

示例：将某数右移 2 位

int x = 20; // 0b00010100
int result = x >> 2; // 右移2位
printf("Result: %d\n", result); // 输出: 5

在嵌入式开发中，位操作非常常见，以下是一些典型应用场景和代码示例：

1. 控制寄存器的位操作

设置某些位

设置寄存器中某些位为 1，比如配置 GPIO 为输出模式。

#define GPIO_DIR_REG  (*(volatile unsigned int *)0x40020000) // 假设寄存器地址
#define GPIO_PIN_3    (1 << 3) // 第3位表示GPIO3

void set_gpio_output() {
    GPIO_DIR_REG |= GPIO_PIN_3; // 设置第3位为1
}

清除某些位

清除寄存器中某些位为 0，比如禁用某外设功能。

void disable_feature() {
    GPIO_DIR_REG &= ~GPIO_PIN_3; // 清除第3位
}

2. 检测某个位的状态

判断某引脚状态

检测某引脚的高低电平。

#define GPIO_INPUT_REG (*(volatile unsigned int *)0x40020010) // 输入寄存器

int is_pin_high() {
    return (GPIO_INPUT_REG & GPIO_PIN_3) ? 1 : 0; // 检查第3位是否为1
}

3. 翻转某个位

翻转 LED 状态

嵌入式中控制 LED 灯时，经常需要翻转某 GPIO 的状态。

#define GPIO_OUTPUT_REG (*(volatile unsigned int *)0x40020004) // 输出寄存器

void toggle_led() {
    GPIO_OUTPUT_REG ^= GPIO_PIN_3; // 翻转第3位
}

4. 提取寄存器的特定位

获取外设状态

从状态寄存器中提取某外设的状态位。

#define STATUS_REG  (*(volatile unsigned int *)0x40020020) // 状态寄存器
#define DEVICE_READY_BIT (1 << 7) // 第7位表示设备准备好

int is_device_ready() {
    return (STATUS_REG & DEVICE_READY_BIT) >> 7; // 提取第7位
}

5. 多位配置操作

设置多位

一次性设置多个位，比如配置多个 GPIO 为输出模式。

#define GPIO_OUTPUT_MASK (GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5)

void configure_multiple_gpio() {
    GPIO_DIR_REG |= GPIO_OUTPUT_MASK; // 设置GPIO3、GPIO4、GPIO5为1
}

清除多位

清除多个位。

void clear_multiple_gpio() {
    GPIO_DIR_REG &= ~GPIO_OUTPUT_MASK; // 清除GPIO3、GPIO4、GPIO5
}

6. 数据压缩与解压

压缩数据

将多个小数据合并到一个 32 位变量中。

unsigned int pack_data(unsigned char a, unsigned char b, unsigned char c, unsigned char d) {
    return (a << 24) | (b << 16) | (c << 8) | d;
}

解压数据

从一个变量中提取多个字段。

void unpack_data(unsigned int packed, unsigned char *a, unsigned char *b, unsigned char *c, unsigned char *d) {
    *a = (packed >> 24) & 0xFF;
    *b = (packed >> 16) & 0xFF;
    *c = (packed >> 8) & 0xFF;
    *d = packed & 0xFF;
}

2.如何求解整型数的二进制表示中1的个数 ?

#include <stdio.h>

int func(int x) {
    int countx = 0; // 计数器初始化
    while (x) {
        countx++;
        x = x & (x - 1); // 清除最低位的1
    }
    return countx;
}

int main() {
    printf("%d\n", func(9999)); // 调用函数并打印结果
    return 0;
}

func 函数：

用于计算输入整数 x 的二进制表示中有多少个 1。

x = x & (x - 1) 的作用是清除 x 中最低位的 1，直到 x 变为 0。

每次清除一个 1 时，countx 增加 1。

main 函数：

调用 func(9999)，计算 9999 的二进制表示中有多少个 1。

使用 printf 输出结果。

输出结果：

9999 的二进制表示为 10011100001111，其中有 8 个 1。

3.如何求解二进制中0的个数还有1的个数

#include <stdio.h>

void count_ones_and_zeros(int x) {
    int count_ones = 0, count_zeros = 0;
    while (x) {
        if (x & 1) {
            count_ones++;  // 如果最低位是 1
        } else {
            count_zeros++;  // 如果最低位是 0
        }
        x >>= 1;  // 右移一位，检查下一位
    }
    // 如果 x 最后的结果为 0，还需要考虑 x 可能有零填充的位
    // 假设我们处理的整数位数为 32 位
    int total_bits = sizeof(x) * 8;  // 通常为 32 位（对于 32 位整数）
    count_zeros = total_bits - count_ones - count_zeros;

    printf("1's: %d, 0's: %d\n", count_ones, count_zeros);
}

int main() {
    int numbers[] = {25, 15, 5};
    for (int i = 0; i < 3; i++) {
        printf("For %d: ", numbers[i]);
        count_ones_and_zeros(numbers[i]);
    }
    return 0;
}

4.交换两个变量的值，不使用第三个变量。即a=3,b=5,交换之后a=5,b=3:

#include <stdio.h>

int main() {
    int a = 3, b = 5;
    
    printf("Before swap: a = %d, b = %d\n", a, b);
    
    a = a + b; // a 变为 8 (3 + 5)
    b = a - b; // b 变为 3 (8 - 5)
    a = a - b; // a 变为 5 (8 - 3)
    
    printf("After swap: a = %d, b = %d\n", a, b);
    
    return 0;
}

a = a + b：a 保存了 a 和 b 的和。

b = a - b：b 通过从 a 的和中减去原来的 b 值，得到原来的 a 值。

a = a - b：a 通过从和中减去新的 b 值，得到原来的 b 值。

#include <stdio.h>

int main() {
    int a = 3, b = 5;
    // a 0011  b 0101
    printf("Before swap: a = %d, b = %d\n", a, b);

    a = a ^ b; // a 变为 6 (3 ^ 5) 0011 0101  - 0110
    b = a ^ b; // b 变为 3 (6 ^ 5) 0110 0101  - 0011
    a = a ^ b; // a 变为 5 (6 ^ 3) 0110 0011  - 0101

    printf("After swap: a = %d, b = %d\n", a, b);

    return 0;
}

a = a ^ b：a 变成了 a 和 b 的异或值。

b = a ^ b：b 通过异或 a（当前是 a ^ b）得到原来的 a 值。

a = a ^ b：a 通过异或 b（当前是原来的 a 值）得到原来的 b 值。

5.给定一个整型变量a，写两段代码，第一个设置a的bit3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。

#include <stdio.h>
#define BIT3 (1<<3)
static int a=5;
void Set_Bit3(void){
    a |= BIT3;
}
void Clear_Bit3(void){
    a &= ~BIT3;
}
int main() {
    Set_Bit3();
    Clear_Bit3();
    printf("%d",a);
    return 0;
}

假设 a 的初始值为 5，其二进制为 00000101：

初始值打印：5

设置第3位后：

BIT3 = 1 << 3 = 00001000

a | BIT3 = 00000101 | 00001000 = 00001101，结果为 13

打印：13

清除第3位后：

~BIT3 = ~00001000 = 11110111

a & ~BIT3 = 00001101 & 11110111 = 00000101，结果为 5

打印：5