C语言：使用宏定义完成位运算
- C语言
- 4天前
- 63热度
- 0评论
什么是宏定义
宏定义的主要作用是在预处理阶段进行文本替换，编译器会按照设定的规则，将代码中出现的宏名替换成对应的文本内容 。
先来看一个简单的例子——定义常量宏。在 C 语言中，定义常量宏使用#define关键字，通过#define关键字为一个常量赋予一个有意义的名字。假设正在开发一个涉及数学计算的程序，其中圆周率π是一个频繁使用的常量，为了提高代码的可读性和可维护性，可以这样定义：
#define PI 3.1415926
在后续的代码中，只要出现PI，编译器就会在预处理阶段将其替换为3.1415926。例如当计算圆的面积时，代码可以写成：
radius = 5.0;
area = PI * radius * radius;
上述代码的PI被替换后，实际的计算就变成了area = 3.1415926 * radius * radius; 这样做的好处是不仅无需反复书写冗长的3.1415926，而且如果后续需要修改圆周率的精度，只需要在宏定义处进行一次修改，整个程序中所有使用PI的地方都会自动更新，提高了代码的可维护性。
使用宏定义完成位操作
使用宏定义完成位操作能够提升代码的可读性和可维护性。在一段复杂的代码中，如果直接使用位操作运算符（如&、|、^、<<、>>）进行各种位运算，代码可能会变得晦涩难懂，让人难以理解代码的用途。通过宏定义，可以将这些复杂的位操作封装成一个具有明确含义的宏，类似给一个复杂的操作贴上了清晰的标签。例如，假设需要定义一个宏来获取一个整数的某一位的值（从右往左数，第n位），可以这样实现：
#define GET_BIT(value, n) ((value) & (1 << (n)))
当在代码中看到GET_BIT(num, 3)时，很容易就能明白这是在获取num这个整数的第 3 位的值，而不需要去仔细研究复杂的位操作符组合。如果后续需要修改获取位的方式，只需要修改宏定义这一处，整个程序中所有使用该宏的地方都会随之更新，降低了代码维护工作量。
宏定义还让位操作代码具有更好的复用性。在实际编程中，很多位操作的逻辑是通用的，比如设置或清除某个位、对一组位进行特定的操作等。通过将这些常用的位操作封装成宏，我们可以在不同的项目、不同的代码模块中方便地复用这些代码，避免了重复编写相同的位操作逻辑。这不仅提高了开发效率，还减少了出错的可能性。
使用宏定义进行位操作还能在一定程度上提高代码的执行效率。由于宏定义是在预处理阶段进行文本替换，没有函数调用的开销，这意味着在程序运行时，位操作的执行速度更快。特别是在对性能要求极高的场景下，如嵌入式系统开发、实时数据处理等，这种效率的提升可能会带来显著的效果。
宏定义实现位运算实战
单独某一位置位
在实际编程中，经常会遇到需要将变量的某一位置为 1 的情况。利用宏定义，可以轻松实现这一操作。
假设要将变量value的第bit_number + 1 位置位（这里从 0 开始计数，所以实际位置是第bit_number + 1 位），宏定义代码如下：
#define SET_BIT(value, bit_number) ((value) | (1 << (bit_number)))
工作原理是首先通过1 << (bit_number)生成一个掩码，该掩码只有第bit_number位为 1，其他位均为 0。然后，使用按位或运算符|将这个掩码与value进行或运算，这样就能将value的第bit_number + 1 位置为 1，而其他位保持不变。
下面通过一个示例代码来验证：
#include <stdio.h>
#define SET_BIT(value, bit_number) ((value) | (1 << (bit_number)))
int main() {
int num = 5; // 二进制为 0000 0101
int bit_number = 2;
int result = SET_BIT(num, bit_number);
printf("原始值 num: %d, 二进制: %08b\n", num, num);
printf("将第 %d 位置位后的值 result: %d, 二进制: %08b\n", bit_number + 1, result, result);
return 0;
}
在上述示例代码中，num的初始值为 5，二进制表示为0000 0101。我们要将第 3 位（bit_number = 2）置位，通过宏SET_BIT(num, 2)，生成的掩码为1 << 2 = 0000 0100，与num进行或运算后，得到结果0000 0101 | 0000 0100 = 0000 0111，即十进制的 7。从输出结果可以看出，第 3 位已经置1。
3.6.3.2.单独某一位复位
与置位相反，复位操作是将变量的某一位设置为 0。同样利用宏定义来实现，假设要将变量value的第bit_number + 1 位复位，宏定义代码如下：
#define CLEAR_BIT(value, bit_number) ((value) & ~(1 << (bit_number)))
工作原理是先通过1 << (bit_number)生成一个掩码，该掩码只有第bit_number位为 1，其他位为 0。然后使用按位取反运算符~对这个掩码取反，得到的新掩码只有第bit_number位为 0，其他位为 1。最后，用这个新掩码与value进行按位与运算&，就能将value的第bit_number + 1 位清零，而其他位保持不变。
以下是示例代码：
#include <stdio.h>
#define CLEAR_BIT(value, bit_number) ((value) & ~(1 << (bit_number)))
int main() {
int num = 7; // 二进制为 0000 0111
int bit_number = 1;
int result = CLEAR_BIT(num, bit_number);
printf("原始值 num: %d, 二进制: %08b\n", num, num);
printf("将第 %d 位复位后的值 result: %d, 二进制: %08b\n", bit_number + 1, result, result);
return 0;
}
在上述示例代码中，num的初始值为 7，二进制表示为0000 0111。要将第 2 位（bit_number = 1）复位，通过宏CLEAR_BIT(num, 1)，生成的掩码1 << 1 = 0000 0010，取反后为1111 1101，与num进行与运算后，得到结果0000 0111 & 1111 1101 = 0000 0101，即十进制的 5。从输出结果可以验证，第 2 位已成功复位。
连续位置位
当需要将变量的多个连续位置位时，宏定义的思路会稍微复杂一些。假设要将变量value的第bit_m + 1 位到第bit_n + 1 位置位（其中bit_m <= bit_n），可以先生成一个合适的掩码，然后再进行按位或运算。
宏定义代码如下：
#define SET_CONSECUTIVE_BITS(value, bit_m, bit_n) ((value) | (((1 << ((bit_n) - (bit_m) + 1)) - 1) << (bit_m)))
宏定义的实现原理：首先，1 << ((bit_n) - (bit_m) + 1)生成一个掩码，该掩码的第((bit_n) - (bit_m) + 1)位为 1，其他位为 0。然后减 1，得到一个从第 0 位到第((bit_n) - (bit_m))位全为 1 的掩码。最后，将这个掩码左移bit_m位，使其对应到需要置位的位置上。再与value进行按位或运算，就能将指定的连续位置位。
下面通过示例代码来验证：
#include <stdio.h>
#define SET_CONSECUTIVE_BITS(value, bit_m, bit_n) ((value) | (((1 << ((bit_n) - (bit_m) + 1)) - 1) << (bit_m)))
int main() {
int num = 5; // 二进制为 0000 0101
int bit_m = 1;
int bit_n = 3;
int result = SET_CONSECUTIVE_BITS(num, bit_m, bit_n);
printf("原始值 num: %d, 二进制: %08b\n", num, num);
printf("将第 %d 位到第 %d 位置位后的值 result: %d, 二进制: %08b\n", bit_m + 1, bit_n + 1, result, result);
return 0;
}
在上述示例代码中，num的初始值为 5，二进制表示为0000 0101。我们要将第 2 位（bit_m = 1）到第 4 位（bit_n = 3）置位。首先计算掩码，1 << ((3 - 1 + 1)) = 1 << 3 = 0000 1000，减 1 后得到0000 0111，左移 1 位后为0000 1110。与num进行或运算0000 0101 | 0000 1110 = 0000 1111，即十进制的 15。从输出结果可以看到，第 2 位到第 4 位已成功置位。
连续位复位
连续位复位是将变量的多个连续位设置为 0，其宏定义方法与连续位置位类似，只是使用按位与运算和相应的掩码。假设要将变量value的第bit_m + 1 位到第bit_n + 1 位复位（其中bit_m <= bit_n），宏定义代码如下：
#define CLEAR_CONSECUTIVE_BITS(value, bit_m, bit_n) ((value) & ~(((1 << ((bit_n) - (bit_m) + 1)) - 1) << (bit_m)))
先生成一个与连续位置位相同的掩码，只不过这个掩码用于清零。通过1 << ((bit_n) - (bit_m) + 1)生成一个掩码，减 1 后得到从第 0 位到第((bit_n) - (bit_m))位全为 1 的掩码，左移bit_m位使其对应到需要复位的位置上，然后对这个掩码取反，最后与value进行按位与运算，就能将指定的连续位复位。
示例代码如下：
#include <stdio.h>
#define CLEAR_CONSECUTIVE_BITS(value, bit_m, bit_n) ((value) & ~(((1 << ((bit_n) - (bit_m) + 1)) - 1) << (bit_m)))
int main() {
int num = 15; // 二进制为 0000 1111
int bit_m = 1;
int bit_n = 3;
int result = CLEAR_CONSECUTIVE_BITS(num, bit_m, bit_n);
printf("原始值 num: %d, 二进制: %08b\n", num, num);
printf("将第 %d 位到第 %d 位复位后的值 result: %d, 二进制: %08b\n", bit_m + 1, bit_n + 1, result, result);
return 0;
}
在上述示例代码中，num的初始值为 15，二进制表示为0000 1111。要将第 2 位（bit_m = 1）到第 4 位（bit_n = 3）复位。首先计算掩码，1 << ((3 - 1 + 1)) = 1 << 3 = 0000 1000，减 1 后得到0000 0111，左移 1 位后为0000 1110，取反后为1111 0001。与num进行与运算0000 1111 & 1111 0001 = 0000 0001，即十进制的 1。从输出结果可以验证，第 2 位到第 4 位已成功复位。
截取部分连续位
在某些情况下，有时需要从一个变量中取出特定的连续位，这可以通过宏定义来实现。假设要将变量value的第bit_m + 1 位到第bit_n + 1 位取出（其中bit_m <= bit_n），实现步骤如下：首先生成一个掩码，该掩码的第bit_m位到第bit_n位为 1，其他位为 0。然后将value与这个掩码进行按位与运算，得到的结果就是需要的连续位。最后，将结果右移bit_m位，使其从最低位开始。
宏定义代码如下：
#define EXTRACT_BITS(value, bit_m, bit_n) (((value) & (((1 << ((bit_n) - (bit_m) + 1)) - 1) << (bit_m))) >> (bit_m))
下面通过示例代码来分析：
#include <stdio.h>
#define EXTRACT_BITS(value, bit_m, bit_n) (((value) & (((1 << ((bit_n) - (bit_m) + 1)) - 1) << (bit_m))) >> (bit_m))
int main() {
int num = 13; // 二进制为 0000 1101
int bit_m = 1;
int bit_n = 3;
int result = EXTRACT_BITS(num, bit_m, bit_n);
printf("原始值 num: %d, 二进制: %08b\n", num, num);
printf("从第 %d 位到第 %d 位取出的值 result: %d, 二进制: %08b\n", bit_m + 1, bit_n + 1, result, result);
return 0;
}
在上面的示例代码中，num的初始值为 13，二进制表示为0000 1101。要从第 2 位（bit_m = 1）到第 4 位（bit_n = 3）取出值。首先计算掩码，1 << ((3 - 1 + 1)) = 1 << 3 = 0000 1000，减 1 后得到0000 0111，左移 1 位后为0000 1110。与num进行与运算0000 1101 & 0000 1110 = 0000 1100，最后右移 1 位0000 1100 >> 1 = 0000 0110，即十进制的 6。从输出结果可以看到，成功从第 2 位到第 4 位取出了值。
综合练习
下面编写一个综合练习程序。这个程序将涵盖单独某一位置位、单独某一位复位、连续位置位、连续位复位以及截取部分连续位等多种宏定义的练习。
#include <stdio.h>
// 单独某一位置位
#define SET_BIT(value, bit_number) ((value) | (1 << (bit_number)))
// 单独某一位复位
#define CLEAR_BIT(value, bit_number) ((value) & ~(1 << (bit_number)))
// 连续位置位
#define SET_CONSECUTIVE_BITS(value, bit_m, bit_n) ((value) | (((1 << ((bit_n) - (bit_m) + 1)) - 1) << (bit_m)))
// 连续位复位
#define CLEAR_CONSECUTIVE_BITS(value, bit_m, bit_n) ((value) & ~(((1 << ((bit_n) - (bit_m) + 1)) - 1) << (bit_m)))
// 截取部分连续位
#define EXTRACT_BITS(value, bit_m, bit_n) (((value) & (((1 << ((bit_n) - (bit_m) + 1)) - 1) << (bit_m))) >> (bit_m))
int main() {
int num = 0b00001111; // 初始值设为15，二进制 00001111
// 单独某一位置位
int set_bit_result = SET_BIT(num, 2);
printf("单独某一位置位：\n");
printf("原始值 num: %d, 二进制: %08b\n", num, num);
printf("将第3位置位后的值 set_bit_result: %d, 二进制: %08b\n", set_bit_result, set_bit_result);
// 单独某一位复位
int clear_bit_result = CLEAR_BIT(num, 1);
printf("\n单独某一位复位：\n");
printf("原始值 num: %d, 二进制: %08b\n", num, num);
printf("将第2位复位后的值 clear_bit_result: %d, 二进制: %08b\n", clear_bit_result, clear_bit_result);
// 连续位置位
int set_consecutive_bits_result = SET_CONSECUTIVE_BITS(num, 1, 3);
printf("\n连续位置位：\n");
printf("原始值 num: %d, 二进制: %08b\n", num, num);
printf("将第2位到第4位置位后的值 set_consecutive_bits_result: %d, 二进制: %08b\n", set_consecutive_bits_result, set_consecutive_bits_result);
// 连续位复位
int clear_consecutive_bits_result = CLEAR_CONSECUTIVE_BITS(num, 0, 2);
printf("\n连续位复位：\n");
printf("原始值 num: %d, 二进制: %08b\n", num, num);
printf("将第1位到第3位复位后的值 clear_consecutive_bits_result: %d, 二进制: %08b\n", clear_consecutive_bits_result, clear_consecutive_bits_result);
// 截取部分连续位
int extract_bits_result = EXTRACT_BITS(num, 1, 3);
printf("\n截取部分连续位：\n");
printf("原始值 num: %d, 二进制: %08b\n", num, num);
printf("从第2位到第4位取出的值 extract_bits_result: %d, 二进制: %08b\n", extract_bits_result, extract_bits_result);
return 0;
}
运行上述代码，输出结果如下：
单独某一位置位：
原始值 num: 15, 二进制: 00001111
将第3位置位后的值 set_bit_result: 19, 二进制: 00010011
单独某一位复位：
原始值 num: 15, 二进制: 00001111
将第2位复位后的值 clear_bit_result: 13, 二进制: 00001101
连续位置位：
原始值 num: 15, 二进制: 00001111
将第2位到第4位置位后的值 set_consecutive_bits_result: 31, 二进制: 00011111
连续位复位：
原始值 num: 15, 二进制: 00001111
将第1位到第3位复位后的值 clear_consecutive_bits_result: 8, 二进制: 00001000
截取部分连续位：
原始值 num: 15, 二进制: 00001111
从第2位到第4位取出的值 extract_bits_result: 3, 二进制: 00000011
