C语言按位与运算符深度解析：掩码、权限与嵌入式位操作

很多刚接触 C 语言的朋友，第一次看到按位与运算符&时，通常会有两种反应：一种是觉得它和逻辑与&&长得太像，少写一个符号，程序结果就完全变样；另一种是记住了“全 1 才为 1”的规则，但完全不知道这个规则在真实项目里到底有什么用，最后只能在选择题里遇到它。

这里先给一个明确判断：按位与不是 C 语言里某个可有可无的语法细节，而是从“把整数当成数值”转向“把整数当成一组二进制开关”的第一道门槛。你理解了它，后面的按位或、异或、移位、掩码、权限系统、嵌入式寄存器操作，都会顺理成章；理解不了它，那些面试题和底层代码里的(n & (n - 1)) == 0、REG &= ~(1 << 3)就会一直像天书。

这篇文章会用一个完整路线图讲透按位与：先讲它在二进制层面的本质，再区分&和&&，然后结合权限管理、奇偶判断、2 的幂检测、哈希取余、寄存器操作等真实场景，给出 5 段可以直接编译运行的 C 代码，最后补充常见坑、排错表和工程建议。读完你不仅能看懂这些代码，还能自己写出位掩码方案，并能在面试中解释每一步的二进制依据。

1. 按位与为什么值得单独花一篇文章

1.1 从一道经典面试题说起

很多公司面试 C 语言岗位时，喜欢考一道看起来“很简单”的题：判断一个正整数是不是 2 的幂。

刚入门的人可能会写一个循环：

int is_power_of_two_loop(int n) { while (n > 1) { if (n % 2 != 0) { return 0; } n /= 2; } return 1; }

这个写法没有错，但效率不是最优。更常见的“标准答案”是这样：

int is_power_of_two_fast(int n) { return n > 0 && (n & (n - 1)) == 0; }

第二次看这行代码的人，往往会被(n & (n - 1)) == 0这个组合吓住：为什么减去 1 再做按位与，就能判断一个数是不是 2 的幂？这里面没有乘法、没有循环、没有浮点运算，只有一次减法、一次按位与和一次比较。

这个问题的答案，正是按位与运算符的本质优势：它直接操作整数的二进制位，而不是数值本身。理解了这个思路，很多看似“神奇”的写法就不再是死记硬背，而是可推导的结论。

1.2 初学者最常见的三个痛点

按位与之所以让很多人卡住，通常来自三个层面的问题。

第一层，语法混淆：&和&&只差一个字符，实际语义却完全不同。1 & 2的结果是 0，而1 && 2的结果是 1。很多新手把&当&&用，条件判断就莫名其妙失败了。

第二层，缺少应用场景：课本只告诉你“按位与的规则是两位都为 1 结果才为 1”，却不告诉你这个规则能干什么。于是学习者记住了规则，却不会迁移，换个题目就不知道从哪里下手。

第三层，底层细节不清：负数怎么按位与？char参与位运算时会发生什么？==和&谁优先级更高？这些细节一旦出现在调试现场，就会让原本简单的代码变得非常难查。

1.3 按位与能解决什么工程问题

按位与在工程中真正解决的是“精准控制一个整数内部的二进制位”。一个int有 32 个 bit，每个 bit 天然就是“开 / 关”的最小单位。通过按位与，你可以只提取某些位、清空某些位、判断某个开关是否打开，而不影响其他位。

典型任务包括：

• 判断一个整数是奇数还是偶数；
• 从状态寄存器中读取某个标志位；
• 用位掩码管理文件或系统的读、写、执行权限；
• 判断一个数是不是 2 的幂；
• 在哈希表中用hash & (size - 1)快速计算槽位索引；
• 在嵌入式开发中通过REG &= ~(1 << n)清零某个寄存器位。

这篇文章后面会逐一覆盖这些场景。

2. 按位与的基础概念与二进制本质

2.1 先理解整数在计算机里的“真实样子”

我们平时写的十进制数，比如 13，在计算机里并不是“13”这个抽象数值，而是一串二进制位：

十进制 13 = 二进制 1101

从右往左看，第 0 位是 1，第 1 位是 0，第 2 位是 1，第 3 位是 1。每一位都有一个权重：第 0 位是 2 的 0 次方，第 1 位是 2 的 1 次方，以此类推。

13 = 1 * 2^3 + 1 * 2^2 + 0 * 2^1 + 1 * 2^0 = 8 + 4 + 0 + 1 = 13

按位与运算，就是在这样一串二进制位上做“一对一”的逻辑判断。

2.2 按位与的运算规则

按位与的符号是单个&，它是一个双目运算符，要求两个操作数都是整数类型。它的规则可以精简成一句话：只有当两个对应二进制位都是 1 时，结果位才是 1，否则结果位是 0。

用真值表表示：

这个规则和逻辑与非常像，只不过逻辑与处理的是“真 / 假”两个值，而按位与处理的是“每一个二进制位”。

2.3 一个具体的计算例子，直观感受位对齐

计算13 & 9：

1101 (十进制 13) & 1001 (十进制 9) -------- 1001 (十进制 9)

从高位到低位逐位比较：

• 第 3 位：1 对 1，结果为 1；
• 第 2 位：1 对 0，结果为 0；
• 第 1 位：0 对 0，结果为 0；
• 第 0 位：1 对 1，结果为 1。

最终结果是二进制1001，也就是十进制 9。

很多人第一次看到13 & 9 == 9会觉得很奇怪：两个数按位与，结果正好等于其中一个数。这是因为 9 的二进制位是 9 的二进制位的“子集”，也就是说 13 中包含 9 的所有置位位。按位与的结果，本质上是两个二进制集合的交集。

2.4 掩码思想：按位与的核心用途

按位与最常见的工程用途，是和“掩码（mask）”配合使用。掩码是一个精心构造的数值，它的作用是帮助我们只保留目标位上的信息。

例如，我想取出一个数的低 4 位，可以这样：

xxxx1010 & 00001111 ---------- 00001010

这里的0x0F（十进制 15，二进制00001111）就是掩码。任何数值和它做按位与，低 4 位会被原样保留，高 4 位会被清零。

更通用的写法是：x & 1取出最低位，x & (1 << k)取出第 k 位。想理解这些写法，你需要知道1 << k会产生一个只有第 k 位是 1、其他位是 0 的整数。

3. 按位与 & 与逻辑与 && 的本质区别

3.1 CPU 层面做的事情完全不一样

&和&&是 C 语言里最容易混淆的一对运算符，但它们做的事情完全不同。

&是位运算符，CPU 会对两个操作数的每一个对应二进制位分别做与运算，结果的每一位都独立产生。

&&是逻辑运算符，CPU 先把两个操作数分别判断为“真”或“假”（非 0 为真，0 为假），然后输出一个逻辑结果，C 语言中这个结果只能是 0 或 1。

举个例子：

int a = 1; int b = 2; printf("%d\n", a & b); // 输出 0 printf("%d\n", a && b); // 输出 1

为什么1 & 2是 0？因为二进制01和10没有任何一个位同时为 1。为什么1 && 2是 1？因为 1 和 2 都是非 0 值，逻辑上都是“真”。

3.2 短路行为完全不同

逻辑与&&具有短路特性：如果左侧表达式已经是 0（假），右侧表达式根本不会执行。

int a = 0; int result = (a != 0) && (b / a > 1); // a != 0 为假，右侧不会执行，不会发生除零错误

按位与&没有短路行为。它要求两侧都是完整的表达式，两侧都会被计算。因此，如果你用&代替&&做条件判断，可能会得到错误结果，也可能带来预期之外的副作用。

3.3 结果类型与使用场景不同

逻辑与的结果只有 0 或 1，通常用在if、while、for的条件表达式中。按位与的结果可以是任意整数，通常用于位提取、位清零、权限判断等场景。

虽然if (a & b)在某些情况下也能表达“是否某位为 1”，但它表达的是“两个数的二进制位是否有交集”，和“a 与 b 都非 0”是完全不同的语义。

3.4 两者的对比表格

4. 运算符优先级、整型提升与负数陷阱

4.1 优先级陷阱：==的优先级高于&

这是新手最容易踩的坑。C 语言中，比较运算符==的优先级高于按位与&，这意味着：

if (a & 1 == 0) // 实际被解析为 a & (1 == 0)

1 == 0的结果是 0，所以这个条件其实变成了a & 0，结果恒为 0，条件永远为假。

正确的写法必须加括号：

if ((a & 1) == 0)

同样的道理，判断权限位时也不能写：

if (perms & PERM_READ == PERM_READ) // 错误

而应该写：

if ((perms & PERM_READ) == PERM_READ) // 正确

原则只有一条：只要表达式中混合了按位运算符和比较运算符，就无条件给位运算部分加括号。

4.2 整型提升：char和short参与位运算时会被提升

C 语言有一条规则：比int短的类型在参与算术运算或位运算时，会被自动提升为int，这个过程叫整型提升。例如：

unsigned char x = 0x0F; unsigned char y = (unsigned char)(~x);

你可能会觉得~x的结果是0xF0，但实际上，x先被提升为int，~x得到的是0xFFFFFFF0，再强制转换回unsigned char才得到0xF0。如果漏掉强制转换，把~x直接赋给int变量，结果会和预期相差很远。

在按位与场景里，整型提升通常不会造成灾难性错误，但它会影响你对结果位宽和符号的判断。比如对unsigned char求反后与某个掩码操作，需要明确最终类型。

4.3 负数参与按位与会怎样

负数在内存中是用补码表示的。以常见 32 位int为例，-1的补码是所有位都为 1：

-1 = 11111111 11111111 11111111 11111111

所以：

int r = -1 & 0xFF; // 结果是 255

因为-1的低 8 位全是 1，和0xFF做按位与后，保留低 8 位，得到0xFF，也就是十进制 255。

更实用的细节是：n & 1判断奇偶性对负数同样成立。因为负数的补码最后一位仍然保留了原数的奇偶性。这一点在面试和实际代码中经常出现。

5. 按位与的经典应用场景与原理

5.1 判断奇偶性：最直观的按位与应用

从二进制角度看，偶数的最低位永远是 0，奇数的最低位永远是 1。因此，只要取出最低位就能判断奇偶：

if (n & 1) { // n 是奇数 } else { // n 是偶数 }

比起n % 2 == 0，这种写法在语义上更接近“检查二进制最低位”。现代编译器通常会把n % 2优化成位运算，所以在普通代码里两者性能差异不大，但理解位运算版本对学习后续内容很有帮助。

5.2 权限管理：用位掩码表示多个开关状态

在真实的系统或框架中，经常需要用一个变量同时记录多个权限或状态。比如 Linux 文件权限、程序功能开关、网络协议标志位等，都可以用一个int的多个位来表示。

假设有三种权限：

#define PERM_READ (1 << 0) // 0b001，可读 #define PERM_WRITE (1 << 1) // 0b010，可写 #define PERM_EXEC (1 << 2) // 0b100，可执行

初始化一个只有读和写权限的变量：

unsigned int perms = PERM_READ | PERM_WRITE;

判断是否有读权限：

if (perms & PERM_READ) { // 有读权限 }

取消写权限：

perms &= ~PERM_WRITE;

这里的核心思想是：权限的“集合”用多个位表达，按位与会告诉你某个权限位是否存在。这种写法不仅省内存，还能通过按位或、按位与、按位取反组合出非常灵活的权限操作，是 C 语言工程中极其常见的模式。

5.3 判断 2 的幂：经典位运算面试题

一个正整数是 2 的幂，意味着它的二进制表示中只有一个位是 1。比如 1、2、4、8、16 对应二进制是 1、10、100、1000、10000。

如果 n 是 2 的幂，那么 n - 1 的二进制会把原来的那一位拆成低位全 1。例如 n = 8：

n = 1000 n - 1 = 0111 n & (n - 1) = 0000

因此(n & (n - 1)) == 0能判断 2 的幂，但要注意 n = 0 时，0 & (0 - 1)也是 0，所以需要单独排除 n > 0。

return n > 0 && (n & (n - 1)) == 0;

这个技巧在判断数组容量、哈希表扩容、内存池对齐等场景中都很常用。

5.4 快速取余：哈希表索引计算的经典写法

在哈希表实现中，如果 table 的容量 size 是 2 的幂，那么计算哈希槽位时可以用：

int index = hash & (size - 1);

当 size 是 2 的幂时，size - 1的二进制是低位全 1，hash & (size - 1)刚好等价于hash % size，但位运算在某些没有除法指令的嵌入式平台或特定性能敏感路径上更高效。

需要注意，这个技巧只在 size 是 2 的幂时成立。如果 size 不是 2 的幂，hash & (size - 1)得到的不是正确余数。另外，现代编译器在编译hash % 8这类模常数表达式时，本身就会优化为位运算，所以普通开发中不要盲目用&替代%，可读性更重要。

5.5 寄存器位清零与状态读取：嵌入式核心操作

在嵌入式开发和操作系统底层，经常需要通过寄存器地址控制硬件。寄存器本质上是一个内存地址对应的整数，每一位都有特定含义。按位与通常配合按位取反完成“清零指定位”的操作：

// 将寄存器第 3 位清零，其他位保持不变 REG &= ~(1 << 3);

拆解来看：

• 1 << 3生成0b1000，表示要操作第 3 位；
• ~(1 << 3)得到0b11110111，第 3 位是 0，其他位是 1；
• REG &= ...等价于REG = REG & ...，把 REG 的第 3 位强制变成 0，其他位不受影响。

读取某个状态标志位时，也用按位与：

if (REG & STATUS_READY) { // 硬件设备已经就绪 }

这里的核心价值是：按位与允许我们在不影响其他位的前提下，精准修改或读取某个特定位。这是纯数值运算做不到的。

5.6 其他应用：IP 地址与子网掩码

网络编程中，判断一个 IP 地址是否属于某个子网，需要把 IP 地址和子网掩码做按位与。例如子网掩码255.255.255.0（即0xFFFFFF00）保留 IP 地址的网络部分，主机部分清零。这个操作在路由判断、防火墙规则匹配中非常常见，本质上仍然是一次按位与加一次比较。

6. 完整示例代码与实现细节

6.1 编译环境

本文示例使用标准 C 语言编写，适用于 GCC、Clang 或 MSVC。如果你的电脑上还没有 C 语言编译环境，Linux/macOS 可直接使用系统自带或安装的 GCC；Windows 上推荐使用 MinGW-w64 或 Visual Studio 的 C 语言开发环境，也可以在 VS Code 中配置 C 语言环境。

编译示例命令：

gcc -std=c11 -Wall -Wextra demo.c -o demo

6.2 示例一：按位与入门与二进制辅助函数

这段代码会打印两个数的二进制形式，并演示13 & 9的结果。由于 C 标准库没有通用的“直接输出二进制”格式符，我们自己实现一个二进制输出函数print_binary，它本身也使用了移位和按位与。

#include <stdio.h> void print_binary(unsigned int n) { int i; for (i = 31; i >= 0; i--) { putchar((n & (1u << i)) ? '1' : '0'); if (i % 4 == 0) { putchar(' '); } } putchar('\n'); } int main(void) { unsigned int a = 13; unsigned int b = 9; unsigned int c = a & b; printf("a = %-3u, 二进制: ", a); print_binary(a); printf("b = %-3u, 二进制: ", b); print_binary(b); printf("a & b = %-3u, 二进制: ", c); print_binary(c); return 0; }

关键逻辑：

• print_binary从第 31 位开始向左到最低位遍历，每次用(n & (1u << i))判断当前位是否为 1；
• if (i % 4 == 0)每 4 位插入一个空格，方便阅读；
• 这里使用1u而不是1，是为了避免符号相关的边界问题。

6.3 示例二：读、写、执行权限系统

这个示例演示真实的权限管理。我们定义三个权限位，并实现打印权限列表、判断权限、撤销权限的功能。

#include <stdio.h> #define PERM_READ (1u << 0) // 0b001 #define PERM_WRITE (1u << 1) // 0b010 #define PERM_EXEC (1u << 2) // 0b100 void print_permissions(unsigned int perms) { printf("权限："); printf("%c", (perms & PERM_READ) ? 'r' : '-'); printf("%c", (perms & PERM_WRITE) ? 'w' : '-'); printf("%c\n", (perms & PERM_EXEC) ? 'x' : '-'); } int main(void) { unsigned int perms = PERM_READ | PERM_WRITE; printf("初始权限：\n"); print_permissions(perms); if (perms & PERM_READ) { printf("判断结果：有读权限\n"); } else { printf("判断结果：无读权限\n"); } perms &= ~PERM_WRITE; printf("撤销写权限后：\n"); print_permissions(perms); return 0; }

关键逻辑：

• PERM_READ、PERM_WRITE、PERM_EXEC的二进制位互不重叠，所以可以用按位或组合权限；
• perms & PERM_READ的结果要么是PERM_READ，要么是 0，在if中可以直接判断真假；
• perms &= ~PERM_WRITE是把写权限位清零，同时不影响其他位。

6.4 示例三：2 的幂检测与边界测试

#include <stdio.h> #include <stdbool.h> bool is_power_of_two(unsigned int n) { return n > 0 && (n & (n - 1)) == 0; } int main(void) { unsigned int samples[] = {0, 1, 2, 3, 4, 5, 8, 16, 24, 32, 100}; int i; int len = sizeof(samples) / sizeof(samples[0]); for (i = 0; i < len; i++) { printf("%u -> %s\n", samples[i], is_power_of_two(samples[i]) ? "是 2 的幂" : "不是 2 的幂"); } return 0; }

关键逻辑：

• 循环中用sizeof(samples) / sizeof(samples[0])计算数组长度，避免写死；
• n > 0排除 0，(n & (n - 1)) == 0判断二进制中是否只有一个 1；
• 这里参数和样本都用unsigned int，避免负数进入判断逻辑产生歧义。

6.5 示例四：哈希表槽位索引的快速取余

这个示例模拟一个容量为 8 的哈希表。因为 8 是 2 的幂，使用hash & 7等价于hash % 8。

#include <stdio.h> #define TABLE_SIZE 8 #define INDEX_MASK (TABLE_SIZE - 1) unsigned int hash(unsigned int key) { // 模拟一个简单的哈希函数：乘以一个奇数再右移 return key * 2654435761u; } int main(void) { unsigned int i; unsigned int keys[] = {100, 200, 300, 400, 500, 600, 700, 800}; for (i = 0; i < sizeof(keys) / sizeof(keys[0]); i++) { unsigned int h = hash(keys[i]); unsigned int idx = h & INDEX_MASK; printf("key = %4u, hash = %10u, index = %u\n", keys[i], h, idx); } return 0; }

关键逻辑：

• INDEX_MASK是TABLE_SIZE - 1，即二进制00000111，确保结果只在 0 到 7 之间；
• hash使用一个常见的乘法散列思路，但不需要展开太多，重点是演示& INDEX_MASK的应用；
• 这里TABLE_SIZE必须是 2 的幂，否则掩码方案不成立。

6.6 示例五：嵌入式风格的寄存器位操作

下面的代码使用普通变量模拟寄存器。真实嵌入式环境中，寄存器通常声明为volatile并指向特定地址，但核心位操作逻辑完全一致。

#include <stdio.h> #include <stdint.h> #define CTRL_REG (*(volatile uint32_t *)0x40001000UL) // 示意地址，真实环境按芯片手册修改 int main(void) { // 用普通变量演示位清零逻辑，避免在未连接硬件的环境下直接访问地址 uint32_t reg = 0xFF; printf("初始值： 0x%08X\n", reg); reg &= ~(1u << 3); printf("清零第 3 位： 0x%08X\n", reg); reg |= (1u << 4); printf("置位第 4 位： 0x%08X\n", reg); if (reg & (1u << 3)) { printf("第 3 位已置位\n"); } else { printf("第 3 位已清零\n"); } return 0; }

关键逻辑：

• CTRL_REG宏展示的是嵌入式开发中的常见定义方式，代码中实际没有访问该地址，而是用reg变量演示；
• reg &= ~(1u << 3)将第 3 位清零，其他位保持原值；
• 真实硬件操作需要注意volatile关键字，避免编译器优化掉对寄存器的重复读写。

7. 运行结果与效果验证

7.1 编译运行

把上面的示例分别保存为demo1.c、demo2.c等文件，逐个编译运行，也可以合并到一个文件里分段测试。

gcc -std=c11 -Wall -Wextra demo1.c -o demo1 ./demo1

如果使用 Windows 命令行，运行方式为：

demo1.exe

7.2 预期输出

示例一预期输出：

a = 13 , 二进制: 00000000 00000000 00000000 00001101 b = 9 , 二进制: 00000000 00000000 00000000 00001001 a & b = 9 , 二进制: 00000000 00000000 00000000 00001001

从输出可以看到，13 & 9得到了 9，因为它保留了两个数中同时为 1 的位。

示例二预期输出：

初始权限： 权限：rw- 判断结果：有读权限 撤销写权限后： 权限：r--

示例三预期输出：

0 -> 不是 2 的幂 1 -> 是 2 的幂 2 -> 是 2 的幂 3 -> 不是 2 的幂 4 -> 是 2 的幂 5 -> 不是 2 的幂 8 -> 是 2 的幂 16 -> 是 2 的幂 24 -> 不是 2 的幂 32 -> 是 2 的幂 100 -> 不是 2 的幂

示例五预期输出：

初始值： 0x000000FF 清零第 3 位： 0x000000F7 置位第 4 位： 0x00000107 第 3 位已清零

7.3 如何判断结果正确

最简单的验证方法，是找一个数手动写出二进制，按位对齐逐位计算，再与程序输出对比。例如计算13 & 9，先写出两个二进制数，逐位做与，最后把结果转回十进制。

如果在做权限或寄存器操作，验证点更明确：只看目标位是否变化，其他位必须保持不变。比如reg &= ~(1u << 3)后，除了第 3 位从 1 变成 0，其余位仍然是 1。

7.4 运行失败时先查什么

如果编译失败，优先检查有没有漏掉头文件、有没有把1u写成1导致移位警告、括号是否匹配。如果运行结果不对，优先检查表达式里是否混用了&和&&，以及是否缺少括号导致优先级出错。

8. 常见问题与排查思路

这里特别提醒：在嵌入式场景中，使用寄存器地址前一定要确认这是你有权限操作的设备寄存器，并且在测试板上验证。不要在生产设备上直接随意修改未知地址，否则可能造成硬件异常。

9. 最佳实践与工程建议

9.1 用宏或枚举定义位常量，不要散落裸数字

权限、标志位、寄存器位号都属于“领域含义”，最好用宏或枚举集中定义。比如#define STATUS_READY (1u << 3)比直接写if (reg & 8)可读性好得多。散落的裸数字不仅难维护，还容易在复制粘贴时出错。

9.2 位运算表达式一律加括号

只要表达式中混合了位运算、算术运算或比较运算，就统一加括号。虽然这看起来有些保守，但能避免一整类优先级问题。更重要的是，代码在团队评审时，阅读者不需要再查运算符优先级表。

9.3 位操作优先使用无符号类型

按位运算和无符号整数的语义更贴合：没有符号位扩展，左移右移行为清晰，结果也更容易预测。除非你能明确说明使用有符号数的原因，否则位操作场景建议使用unsigned int、uint32_t等无符号类型。

9.4 给位操作写清楚注释

位运算代码很紧凑，但可读性通常不如普通算术代码。建议在复杂的位操作附近写一行注释，说明意图。例如：

// 清零 CTRL_REG 的第 3 位，用于关闭某外设功能 CTRL_REG &= ~(1u << 3);

注释要写“为什么这么做”，而不是重复代码本身。

9.5 不要为了“炫技”而滥用位运算

在普通业务代码中，可读性通常比微小的性能差异更重要。比如hash & (size - 1)虽然高效，但如果团队不熟悉位运算，直接写hash % size反而更容易维护。现代编译器对很多取模表达式已经能自动优化，位运算的优先使用场景应该是：底层驱动、高频路径、嵌入式系统、协议解析等真正对性能和资源敏感的地方。

9.6 面试和学习中：把位运算当成“可推导”的结论

不要死记(n & (n - 1)) == 0这样的结论。更好的做法是，拿到一个问题先画出二进制，你很快会发现规律。比如 8 是1000，8 - 1是0111，两者按位与为 0，于是判定为 2 的幂。这种“从二进制推导”的能力，比记住任何一条位运算结论都重要。

10. 总结与后续学习方向

按位与运算符&看起来只是“两位都为 1 结果才为 1”这么简单，但它是 C 语言位运算体系的地基。这篇文章讲清了几个关键点：

• 按位与操作的是整数的二进制位，掩码思想是它的核心用途；
• 按位与&和逻辑与&&在语义、短路行为、结果类型上都不同；
• 优先级和整型提升是代码出错的常见根源，统一加括号可以规避大部分问题；
• 经典应用包括奇偶判断、权限标志位、2 的幂检测、哈希取余、寄存器位清零、子网掩码计算；
• 工程中要优先使用无符号类型、集中定义位常量、分清可读性和性能的取舍。

后面你可以继续学习按位或|、按位异或^、按位取反~和移位运算符<<、>>。它们和按位与一起，构成了 C 语言中完整的位操作工具箱。理解了按位与之后，你会发现这些运算符的学习成本会低很多，因为你的思维方式已经不再是“数值怎么变”，而是“一个个二进制位如何组合、掩蔽、翻转和移动”。

以后看到x & y，你的第一反应应该不是“这两个数相乘会怎么样”，而是“它们在二进制位上产生了什么交集”。这个思维转换，才是按位与真正教给你的东西。