问我“位运算符到底有什么用”的人，比问“怎么用位运算符”的还多。不管在C还是Java、Python里，教科书总喜欢把“交换两个变量不用临时变量”这种题目往位运算上靠，搞得很多新手以为位运算就是面试里的炫技题。但实际上，位运算符在真实项目里到处都是：TCP协议头里那些SYN、ACK、FIN标志，文件系统里r、w、x权限，Redis的bitmap去重，甚至HashMap为什么长度必须是2的幂，都是位运算的功劳。这篇文章我打算把位运算符的实际应用场景一次性讲透：先从最基础的六个运算符和极易踩的坑说起，再用C语言实现几个可直接拿走的例子，讲清楚它到底什么时候值得用、什么时候别乱用。
1. 先补地基：位运算是什么，以及六个基础运算符
1.1 位运算的心智模型：把二进制看成开关
位运算直接对二进制位操作，和普通算术运算最大的区别在于，它不把“10”当做一个整体，而是把每一位都当成一个独立的开关。你写的a & b，实际上是同时处理a和b的几十个bit，每个bit的结果都不依赖别的bit，所以CPU可以一条指令同步算完所有位。这也是位运算天生适合做状态判断的原因。
我习惯把二进制位想象成墙上一排开关：&是两个开关串联，必须两个都闭合才通电；|是两个开关并联，任何一个闭合就通电；^是双控开关，两个状态不一样才通电；~是直接把整排开关全部拨反。这样理解之后，后面所有的应用场景都顺了。
高级语言里我们很少直接碰位，因为编译器把大部分操作封装成了bool、集合、枚举，但只要你往底层走一点——嵌入式寄存器、网络协议、图像处理、数据库存储引擎——到处都是位运算的天下。尤其是C语言，位运算符的用法几乎是必考基本功，不是因为它花哨，而是因为C本来就离硬件近，一个int就是实实在在的32个bit，你不用就浪费了。
1.2 六个运算符一张表讲透
C语言里有六个位运算符，我直接列成表格，方便对照着看：
| 运算符 | 含义 | 例子（按4位示意） | 结果 | 记忆口诀 |
|---|---|---|---|---|
& | 按位与 | 0b1100 & 0b1010 | 0b1000 | 两个都是1才为1 |
| | 按位或 | 0b1100 | 0b1010 | 0b1110 | 只要有一个1就为1 |
^ | 按位异或 | 0b1100 ^ 0b1010 | 0b0110 | 不一样才为1 |
~ | 按位取反 | ~0b1100（4位） | 0b0011 | 0变1，1变0 |
<< | 左移 | 0b0001 << 3 | 0b1000 | 末尾补0，相当于乘以2 |
>> | 右移 | 0b1000 >> 3 | 0b0001 | 正数高位补0，相当于除以2 |
例子里的0b写法是为了直观，C23标准才正式支持二进制字面量，以前主流是用十六进制或十进制写，比如上面的0b1100实际写作0x0C、0b1010写作0x0A。我在代码示例里尽量用十六进制和十进制，兼过兼容性。
这里要特别提醒的是，位运算符和逻辑运算符&&、||根本不是一回事。位运算返回的是逐位计算后的整数，没有“短路”概念；逻辑运算返回的只有0或1，而且有短路求值。很多人一急就写成if (flags & FLAG)，这本身没问题，但如果你写if (flags && FLAG)，那就把按位与和逻辑与混在一起了，语义完全不同，结果也容易莫名其妙。
1.3 移位运算的数学本质
移位是位运算里最有“数学感”的两个。左移x << n等价于x * 2^n，只要没发生溢出，低位补的0就是在告诉CPU“这个数变大了2的n次方倍”。右移x >> n对正数来说等价于x / 2^n，而且带向下取整，7 >> 1得到3而不是3.5，因为没有小数位。
一个常见的误解是“位运算一定比算术快”。其实现代编译器早就会把这些常规优化做了：你写x * 8，很多编译器直接生成x << 3的指令；你写n % 2，编译器也可能优化成n & 1。所以早期核心代码里手动做移位，更多是在提醒自己“这里就是一个乘以/除以2的语义”，或者在一些不允许用除法的嵌入式环境里才必须这么写。
真正需要手动控制移位的地方，是造数据、拆数据：比如把RGB三通道打包进一个32位整数，把IP地址拆成四个段，把TCP标志位塞进一个字节。这类场景你不自己移位，数据就拿不出来。另外还有一个关键点：移位位数不能超过类型位宽，uint32_t x = 1; x << 32在C里是未定义行为，程序可能直接跑飞，这也是后面避坑章会展开的重点。
2. 状态与权限：位运算最实在的日常用法
2.1 状态标志：一个int顶十个bool
平时写业务很喜欢用一堆bool变量记录状态：is_online、is_verified、is_admin……一个功能加一个bool，最后整个结构体全是flag，不仅占内存，传输时还要一个字段一个字段地打包。用位运算的做法是，只用一个整数，每一位代表一个开关状态。
举个最典型的例子：TCP三次握手里SYN、ACK、FIN这些标志，就是挤在同一个字节里的。Linux内核源码里你会看到类似这样的定义，C语言位运算符的用法在这里体现得淋漓尽致：
#define TCP_FIN 0x01 // 1U << 0 #define TCP_SYN 0x02 // 1U << 1 #define TCP_RST 0x04 // 1U << 2 #define TCP_PSH 0x08 // 1U << 3 #define TCP_ACK 0x10 // 1U << 4 #define TCP_URG 0x20 // 1U << 5解析报文时，整个头只要拿到一个字节，就能同时确认这个包是同步包、带确认还是要断开连接。如果你想模拟“设置多个状态”，直接按位或：
uint8_t flags = TCP_SYN | TCP_ACK; // 0x12这条语句只做一次或运算，就把两个状态同时写进一个变量，网络协议栈传输时也只需要一个字节。后面想检测某个状态是否存在，用与运算：
if (flags & TCP_SYN) { // 这个包带SYN }这一个模式，可以被推广到任何“枚举多个开关状态”的场景：配置项热更新、后台服务开关、游戏角色Buff状态、聊天消息的提醒类型。用一个uint32_t，等于拿到了32个bool，而且状态之间天然互不干扰。
2.2 权限设计：rwx与chmod的底层逻辑
权限管理是位运算最经典、最接地气的应用，Unix的chmod 755就是教科书级别的例子。rwx三个权限不能互相覆盖，所以每个文件权限用一个八进制位表示：r是4，w是2，x是1。4、2、1相加能组合出0到7所有值，这就是“二进制位相加”的直观结果。
7 = 4+2+1，表示可读可写可执行；5 = 4+1，表示可读可执行但不可写。之所以能做到绝不混叠，就是因为每个权限占独立的一个bit。
自己写业务系统时，我常定义这样的权限枚举：
enum { PERM_READ = 1 << 0, // 1 PERM_WRITE = 1 << 1, // 2 PERM_EXEC = 1 << 2, // 4 PERM_DELETE = 1 << 3, // 8 };然后给角色配置权限时是perm = PERM_READ | PERM_WRITE，检查权限时是(perm & PERM_READ) != 0，加权限是perm |= PERM_WRITE，减权限是perm &= ~PERM_WRITE。这套思路在数据库用户权限、后台管理系统的角色权限、接口访问控制里都能直接套用，好处是内存极小、判断极快、所有权限状态可以一次性序列化存进数据库的一个int字段，不用建一堆关联表。
2.3 位图集合：用1个bit代替1个字节
如果说状态标记是用位“省字段”，那位图（bitmap）就是用位“省内存”。假设你要记录一百万个用户ID是否已经签到，用bool visited[1000000]，C语言里bool通常占1字节，那就是大约1MB；用位图的话每个ID只占1bit，只需要125KB。数据量越大，差距越明显。
位图本身可以理解成一个超大的位集合：第i位置1表示“元素i存在”。它的内存定位方式非常规律，一个字节管8个元素，所以我们要找第i个元素时：
bits[i >> 3] // i / 8，定位到哪个字节 bits[i >> 3] |= (1U << (i & 7)); // 定位到字节内的第几位，置1这里i >> 3和i & 7就是除法和取模的位运算版本，因为8正好是2的3次方。很多初学者第一次看到这段代码会懵，但只要记住一句话：对2的幂做除法/取模，可以改成右移和与运算。
位图不只省内存，还自带了集合运算能力：位图的交集就是按位与，并集就是按位或，对称差就是异或。你要算“同时满足条件A和B的用户”，把A的位图和B的位图直接&一遍，遍历结果的时候每个字节还可以一次判断8个元素，速度非常快。Redis里的SETBIT、BITCOUNT，C++的std::bitset，Java的BitSet，底层都是这个原理。
2.4 多事件监听：一次&判断全部
做网络编程的人对epoll的事件掩码一定不陌生，EPOLLIN、EPOLLOUT、EPOLLERR这些常量都是用位运算定义的事件标志。一个socket上同时可能有多种事件发生，事件结构体里用一个int把它们全部记录下来，你判断时逐个按位与就行。
游戏输入也常用这套：方向键的“上、下、左、右”是四个独立按键，但是用户经常同时按，你总不能为每一种组合都写if。把四个键位定义成1<<0到1<<3，按下去的组合就是UP | RIGHT，判断是否包含右方向就是(keys & RIGHT) != 0。一次键盘事件读取，一个字节就装完了所有按键状态，传给别人也方便。
这种“多状态同时检测”的思路，在UI框架的事件系统、后台分布式任务的状态上报里也经常遇到。核心好处是所有状态都紧凑地放在同一个变量里，不仅判断分支可以写得很集中，做快照、做日志、做网络传输都是一个小整数，开发调试时一眼就能看穿。
3. 算法和性能优化：位运算成神的地方
3.1 奇偶判断、取模和快速幂
先说奇偶判断。最直白的写法是n % 2 == 0，但有经验的C程序员会写(n & 1) == 0。道理很简单：偶数的二进制最低位一定是0，奇数是1，所以n & 1等于0就是偶数，等于1就是奇数。这个写法在教科书和面试里出现频率极高，真正让我觉得“值钱”的是它背后那种“从位级理解数据”的思维方式。
比奇偶判断实用得多的是取模优化：当一个数m是2的幂时，x % m等价于x & (m - 1)。因为2的幂次减1之后，低n位全是1，比m大的高位全是0，按位与正好把高n位全部清零，留下低n位就是余数。比如x & 7就是x % 8。这就是为什么哈希表容量是2的幂时，可以直接用hash & (size - 1)代替hash % size计算槽位。这个优化在日常开发里处处可见，后面会再提到。
快速幂是另一个经典。计算一个数的n次方，最朴素的做法是循环乘n次，但用位运算拆解指数，可以把复杂度降到对数级：
uint64_t fast_pow(uint64_t base, uint64_t exp) { uint64_t result = 1; while (exp) { if (exp & 1) result *= base; // 当前二进制位是1就乘一次 base *= base; // base自乘 exp >>= 1; // 指数右移一位 } return result; }原理是：任何正整数指数都可以用二进制展开，比如x^13 = x^(8+4+1)，指数13的二进制是1101，程序每右移一位就是在“消费”一个二进制位，当前位置是1就把对应的乘积累加进结果。这个套路在加密算法、大数运算、矩阵快速幂里都通用。
3.2 交换变量、绝对值和符号判断
a ^= b; b ^= a; a ^= b;这段不用临时变量交换两个整数的代码，几乎成了位运算的“吉祥物”。虽然日常开发里我会直接写临时变量，因为它更安全、意图更清楚，但理解异或交换的原理还是有价值的：第一次异或把a变成了a和b的差异集合，第二次用b和差异集异或还原出a，第三次再用差异集和还原出的a异或还原出b。整个过程里两个原数的信息都藏在异或结果里，所以能无损复原。
不过这个写法有个很大的坑：如果a和b指向同一个变量，第一次异或后这个变量就变成0了，后面再怎么异或都回不来。我见过有人拿它做数组内两个元素交换，结果swap(a[i], a[j])在i == j时把元素清零，排查半天。所以实际项目里我还是那句话：老老实实写临时变量，炫技留给作业题。
判断一个数的正负符号，也可以从符号位入手，32位整数的最高位是符号位，x >> 31后非负数得到0，负数得到-1（算术右移），所以：
int mask = x >> 31; int abs_x = (x ^ mask) - mask;当x是非负数时mask为0，x ^ 0还是x，减去0不变；当x是负数时mask为-1（全1），x ^ -1等于把x按位取反，再减去-1等价于加1，正好补全二进制补码转换，得到绝对值。这段代码在内存受限的嵌入式环境里有人用，但要注意INT_MIN的绝对值会溢出，并且可读性真的很一般，我建议只在紧循环里确认需要时才用。
还有一个面试很爱的技巧：判断两个整数是否同号，直接看(a ^ b)的符号位。异或结果的最高位为1，说明两个数的符号位不同，即异号；最高位为0就是同号。这个判断比分别判断再比较要少一次分支，代码写出来也就一行。
3.3 掩码、提取与拼装：IP、颜色、压缩编码
凡是“把多个小整数打包进一个大整数，或者从大整数里拆出小整数”的场景，位运算都是主角。最典型的是颜色。一张RGBA图像每个像素32位，R、G、B、A各8位，打包成uint32_t后如果要取R通道：
uint8_t r = (pixel >> 24) & 0xFF; uint8_t g = (pixel >> 16) & 0xFF; uint8_t b = (pixel >> 8) & 0xFF; uint8_t a = pixel & 0xFF;这里的0xFF就是掩码，作用是只保留低8位，把高位全部清零。先右移再与运算，本质上回答了两个问题：这个字节在哪个位置？我只关心8个bit怎么把其他位去掉？
反过来拼装则是(r << 24) | (g << 16) | (b << 8) | a。IP地址从点分十进制转换成32位整数，字节序转换，大端小端互换，全是同一套位移加掩码的套路。还有一个比较隐藏的场景是Base64编码，它把三个字节共24位拆成四个6位，每个6位映射成一个可见字符。拆6位的代码就是：
b1 = (bytes[0] >> 2) & 0x3F; b2 = ((bytes[0] & 0x03) << 4) | ((bytes[1] >> 4) & 0x0F); b3 = ((bytes[1] & 0x0F) << 2) | ((bytes[2] >> 6) & 0x03); b4 = bytes[2] & 0x3F;不理解位移和掩码，这段代码就完全没法维护；理解了之后，你能一眼看出它是在“跨字节搬运位”。所有二进制编解码、压缩算法、加密算法里，这种位搬运到处都是。
3.4 哈希槽位与布隆过滤器：位运算让哈希表起飞
JavaHashMap的源码里有一个广为人知的细节：数组容量设计成2的幂，然后定位下标时用hash & (len - 1)而不是hash % len。这样做的原因有两个：一是按位与在硬件上就是一个周期的事，整数除法相对慢；二是当len是2的幂时，hash & (len - 1)能保证结果落在0到len-1之间，和取模完全等价。
布隆过滤器则是位图和多个哈希函数结合的标准玩法。它里面就是一个大概率是位图结构的数组，插入元素时用k个哈希函数算出k个位置，把这些位全部置1；查询时看这k个位置是否全部为1，只要有一个为0，元素一定不存在，全部为1只能说“可能存在”。它的内存占用跟元素个数和误判率有关，想真正落地时，给hash结果做槽位映射几乎必然要写hash & (bits - 1)这类位运算，因为布隆过滤器的位数组长度也常被设计成2的幂。
我自己做爬虫去重时，用位图把一个上亿级的URL指纹集合压到几百MB以内，核心代码就是第2章那个bits[i >> 3] |= (1U << (i & 7))。这种场景用普通哈希表存字符串几乎不可能，因为每个字符串本身的开销就超过几十字节，而位图只关心指纹bit位上有没有“烫”过。
3.5 树状数组和状态压缩DP：算法的硬核应用
算法竞赛里，位运算更是家常便饭。先说树状数组（Fenwick Tree），它的核心操作i += i & -i和i -= i & -i用到的lowbit就是位运算最著名的“提取最低位1”操作。为什么x & (-x)能提取最低位？因为负数在补码里是~x + 1，这个加1操作会把x中最右边的那个1变成进位停止点，从而让-x只保留与x公共的最低位1。树状数组进行前缀和更新、查询时，就靠这个lowbit一圈圈往上跳。
状态压缩DP又是另一片战场。比如旅行商问题，状态用一个整数mask表示“已经访问过的城市集合”，mask的第i位是1代表去过城市i。转移时判断某城市是否在集合里，一行mask & (1 << j)就完成了；把城市j放进集合，写成mask | (1 << j)。N皇后问题判断列冲突和对角线冲突，也常常用三个整数分别记录列、主对角线、副对角线被占用的位置，再用位运算做排除。这种写法把空间复杂度压缩到了极小，而且常数小，跑起来比纯bool数组快不少。
4. C语言实战：四个可以直接抄的位运算案例
下面的代码我都用标准C99验证过，编译器用的gcc，可以直接编译运行。如果你想上手试，复制到本地或者在线编译器里跑就行。这几个例子都不长，但覆盖了“状态标志、位图、协议解析、图像处理”四个最常见的位运算方向。
4.1 用位运算实现一个权限系统
这个权限系统基本覆盖了最核心的“加权限、减权限、查权限”。我把宏定义、权限枚举和操作函数分开写，方便你直接搬进项目里改改就用：
#include <stdio.h> enum { PERM_READ = 1 << 0, // 1 PERM_WRITE = 1 << 1, // 2 PERM_EXEC = 1 << 2, // 4 PERM_DELETE = 1 << 3 // 8 }; int has_perm(unsigned perm, unsigned need) { return (perm & need) == need; // 必须全部包含 } int has_any_perm(unsigned perm, unsigned need) { return (perm & need) != 0; // 只要包含一个 } void grant_perm(unsigned *perm, unsigned flag) { *perm |= flag; } void revoke_perm(unsigned *perm, unsigned flag) { *perm &= ~flag; } int main(void) { unsigned user = PERM_READ | PERM_WRITE; printf("has read: %d\n", has_perm(user, PERM_READ)); printf("has delete: %d\n", has_perm(user, PERM_DELETE)); printf("has read or write: %d\n", has_any_perm(user, PERM_READ | PERM_WRITE)); grant_perm(&user, PERM_EXEC); printf("after grant exec: %d\n", has_perm(user, PERM_EXEC)); revoke_perm(&user, PERM_WRITE); printf("after revoke write: %d\n", has_perm(user, PERM_WRITE)); return 0; }这里有个细节值得说道：revoke_perm里用的*perm &= ~flag，核心思路是先取反flag，比如~PERM_WRITE就是除了第1位变0以外，其他位全变1，再和原权限按位与，就能把目标位清零，同时保持其他位原样。这个“取反+与”的模式比直接赋值安全得多，因为它不会把其他权限覆盖掉。
has_perm和has_any_perm的区别也有讲究：有时我们需要“同时拥有读和写”才算通过，有时只要“有读或写任意一个”就算有权限入口，两个函数正好覆盖这两种语义，避免你在调用处还要自己再写一遍逻辑。
4.2 用位图实现一个百万级去重器
这个案例能直接看出位图省内存的硬效果。假设我们要对0到100万之间的整数做存在性去重，按常规思路开一个int数组，需要约400万字节；改成位图，只需要125KB，差距超过30倍。代码里我写了设置、查询、清除三个最常用的操作：
#include <stdio.h> #include <string.h> #define BITMAP_SIZE(n) (((n) + 7) / 8) void bitmap_set(unsigned char *bits, unsigned int i) { bits[i >> 3] |= (unsigned char)(1U << (i & 7)); } void bitmap_clear(unsigned char *bits, unsigned int i) { bits[i >> 3] &= (unsigned char)~(1U << (i & 7)); } int bitmap_test(const unsigned char *bits, unsigned int i) { return (bits[i >> 3] >> (i & 7)) & 1U; } int main(void) { unsigned char bits[BITMAP_SIZE(1000000)]; memset(bits, 0, sizeof(bits)); bitmap_set(bits, 12345); bitmap_set(bits, 999999); printf("12345 exist? %d\n", bitmap_test(bits, 12345)); printf("12346 exist? %d\n", bitmap_test(bits, 12346)); bitmap_clear(bits, 12345); printf("after clear, 12345 exist? %d\n", bitmap_test(bits, 12345)); return 0; }bits[i >> 3]就是bits[i / 8]，因为一个字节管8个bit，定位到字节后，i & 7取余数得到在这个字节内的第几位。置1用按位或，查1用右移和按位与，清0用取反和按位与。这几个操作的组合就是位图库里最底层的基本单元。
实际生产环境我还会稍微改造一下：如果只做“一次性去重”，直接把所有新增元素set进去，最后遍历统计或者按序号查询；如果数据范围不确定，就先动态扩容位数组。要注意位图不适合做“计数”，它只能回答“有没有”，回答不了“有几个”。想统计频率就得用“计数型布隆过滤器”或者换哈希表，别硬往上套。
4.3 解析TCP报文头部的FLAGS字段
前面提到TCP协议的标志位都压缩在同一个字节里，这里就写一个极简解析函数。拿一段原始的网络数据包，从第14字节（TCP头在以太网头之后，实际上要从IP层再往后算，我这里简化为“已经拿到TCP头起始位置”）开始取标志字节，然后逐个判断：
#include <stdio.h> #include <stdint.h> #define TCP_FIN 0x01 #define TCP_SYN 0x02 #define TCP_RST 0x04 #define TCP_PSH 0x08 #define TCP_ACK 0x10 #define TCP_URG 0x20 #define TCP_ECE 0x40 #define TCP_CWR 0x80 void dump_tcp_flags(uint8_t flags) { if (flags & TCP_FIN) printf("FIN "); if (flags & TCP_SYN) printf("SYN "); if (flags & TCP_RST) printf("RST "); if (flags & TCP_PSH) printf("PSH "); if (flags & TCP_ACK) printf("ACK "); if (flags & TCP_URG) printf("URG "); if (flags & TCP_ECE) printf("ECE "); if (flags & TCP_CWR) printf("CWR "); printf("\n"); } int main(void) { dump_tcp_flags(TCP_SYN); // 输出 SYN dump_tcp_flags(TCP_SYN | TCP_ACK); // 三次握手第二个包 dump_tcp_flags(TCP_FIN | TCP_ACK); // 正常断开连接时常见 return 0; }代码本身不复杂，但它背后是网络协议栈的通用模式：协议头为了节省空间，经常把多个标志位塞进一个字节甚至一个bit里，解析时谁用谁把对应位“抠”出来。如果你做过抓包，会发现Wireshark里显示的[SYN] [ACK]其实就是从这一个字节里按位拆出来的。
这个案例最值得学习的不是TCP细节，而是“一个字节可以拆出8个独立状态”的思维方式。同样的结构，你用在自己的自定义私有协议里就能让包体体积减少一大截，在物联网、游戏同步这类带宽敏感场景里非常有用。
4.4 RGB转灰度：处理图像像素的位运算姿势
图像处理是位运算的另一个高频场景。一个很常见的小功能是把彩色图转成灰度图，标准公式是Y = 0.299R + 0.587G + 0.114B，但实际实现为了避免浮点运算，通常会放大成整数近似，然后再右移缩小。经典快速写法：
#include <stdio.h> #include <stdint.h> uint8_t rgb_to_gray(uint8_t r, uint8_t g, uint8_t b) { uint32_t sum = (uint32_t)r * 77 + (uint32_t)g * 150 + (uint32_t)b * 29; return (uint8_t)(sum >> 8); // 除以256 } int main(void) { uint32_t pixel = 0x336699FF; // RGBA: R=0x33 G=0x66 B=0x99 A=0xFF uint8_t r = (pixel >> 24) & 0xFF; uint8_t g = (pixel >> 16) & 0xFF; uint8_t b = (pixel >> 8) & 0xFF; uint8_t a = pixel & 0xFF; printf("R=%u G=%u B=%u A=%u\n", r, g, b, a); printf("gray=%u\n", rgb_to_gray(r, g, b)); return 0; }这里的77 + 150 + 29加在一起是256，所以右移8位相当于除以256，本质上就是把0.299、0.587、0.114这些小数放大256倍后取整，再用一次移位完成除法。每像素处理时零浮点、零除法，在嵌入式图像采集设备上能明显降低CPU负担。
理解这个写法之后你会发现，图像格式转换、颜色空间转换、音量调节、信号采样，大量领域都在用“整数乘加 + 右移”替代浮点运算。这个技巧在涉及性能瓶颈时尤其值得拿出来用，但别忘了代码里要注释清楚系数来源，否则过一个月你自己都忘了77是从哪来的。
4.5 顺带一提：探测大小端的位运算
很多人写跨平台网络程序时会遇到大小端问题。判断当前机器是大端还是小端，用位运算可以一行搞定：
int is_little_endian(void) { uint32_t x = 1; return *(uint8_t *)&x == 1; }原理是：内存里存一个整数1，如果低地址字节是1，说明低位字节先放，就是小端；反之是大端。这一段看起来很“指针”，不是纯位运算，但它背后的逻辑和移位是一体的：你想把一个32位IPv4地址拆成四个字节，或者把四个字节拼成一个整数，都必须先搞清楚内存字节序，否则位运算是反的。C标准里网络字节序统一规定为大端，所以跨平台协议解析前做一次ntohl这类转换几乎必不可少。
5. 避坑清单：位运算就这些地方容易翻车
5.1 运算符优先级：& 和 == 的大坑
C语言位运算最大的坑之一，是运算符优先级。说句实话，哪怕写了好几年C的人，也经常在这里翻车。问题是这样的：关系运算符和相等运算符（==、!=）的优先级比位运算的&、^、|更高，所以如果你写：
if (flags & FLAG == FLAG) { ... }编译器会解析成：
if (flags & (FLAG == FLAG)) { ... }FLAG == FLAG是1，于是它变成了flags & 1，跟你想要的“检查是否包含FLAG”八竿子打不着。我见到过真实代码里有这种bug，查了半天还以为是改了什么宏。
我的建议很简单：所有位运算表达式都加括号，判断条件也写得明确一点。(flags & FLAG) != 0或(flags & FLAG) == FLAG，哪怕多打几个字符，也比让后来人猜你的意图强得多。C语言优先级简表里，!大于算术运算符，大于移位，大于关系，大于相等，再大于位与、异或、位或，最后才是逻辑与、逻辑或。这个顺序记不住也没关系，反正一律括号包住就完了。
5.2 负数右移：C的“实现定义”和Java的 >>>
C标准对负数右移的结果有一个很憋屈的规定：它属于implementation-defined，也就是“编译器自己看着办”。gcc和大多数现代编译器在x86上采用算术右移，符号位扩展，所以-8 >> 1得到-4；但理论上平台可以选逻辑右移，变成一个大正数。这就导致一段代码在本地测试正常，换一个交叉编译环境结果就变了。
如果你需要确定性的逻辑右移行为，先把负数转成无符号类型再移：
int x = -8; unsigned int u = (unsigned int)x >> 1;这样保证高位补0，结果确定。Java语言就干脆多了，>>是算术右移，保留符号位；>>>是无符号右移，高位补0。C语言没有内置>>>，所以你只能自己手动转无符号。日常写业务代码时尽量别依赖负数右移，老实声明无符号类型，语义清楚又安全。
5.3 位宽与类型符号扩展：char的坑
char c = 0x80;这一行就能引出不少问题。因为C标准没有规定char有没有符号，有的平台默认是带符号char，有的默认是无符号char。如果c是带符号char，那么它的值是负数（0x80对应-128），做c >> 1的时候算术右移会得到0xC0；如果c是无符号char，右移得到0x40。你要是拿这个结果去查表，直接定位错位置。
这个坑在解析网络报文、加密数据时尤其容易踩，因为里面充斥着原始字节。我现在处理字节统一用uint8_t，处理位域统一用uint32_t这些<stdint.h>里的固定宽度类型，不再依赖 int 是32位还是char有没有符号。移位也要注意：1 << 31是有符号整数的未定义行为，因为溢出到符号位了，正确写法是1U << 31。
还有一个隐藏的坑是整型提升。uint8_t a = 1, b = 2;然后你写~a，表达式里的a会先被提升成int，取反结果可能是-2而不是0xFE，如果你要把它塞回uint8_t，必须显式转换。这类细节平时不容易发现，但一旦通过printf("%u", ~a)打印你就会傻眼。
5.4 可读性与维护性：别为了炫技写天书
位运算最大的缺点是读起来不直观。一个裸写的if ((flags >> 3) & 1)完全看不出你在判断什么，代码评审环节大概率会被要求改成语义清晰的写法。我自己踩过几次坑后，总结了一条经验：位运算用在“定义明确、注释齐全”的地方，效果是神器；用在“随手一写、没有上下文”的地方，就是事故。
具体做法上，我建议：
- 所有位运算的bit位，要么用宏命名，要么用枚举命名，别让魔法数字裸奔。
- 每个位标志旁写一行注释，说明这个位是干嘛的，比如
// bit0: 是否已读。 - 用
(1U << n)这种形式定义位，不只是n，这样一看就知道是位掩码。 - 校验一个整数是否“同时包含多个位”，写成
(value & mask) == mask，别简写成value & mask，因为后者等于0时不满足条件，语义很容易被忽略。
代码是给别人看的，尤其是半年后的自己。位运算带来的性能收益通常很小，但可读性损失立竿见影，所以我在非性能关键路径上，宁愿写x % 2 == 0也不写(x & 1) == 0，反正编译器会帮我优化。
5.5 性能不是万能药：什么时候才真正受益
讲了这么多位运算的厉害之处，最后得说句公道话：位运算不是所有场景的性能救世主。现代编译器非常聪明，x % 2在开了优化之后可能直接变成x & 1，x * 4也可能变成移位指令，你手写位运算并不会带来数量级的提升。真正收益明显的地方，是这三类：
- 内存受限：位图代替bool数组，省下87.5%内存，这是数量级的收益。
- 循环内的大量简单运算：图像像素遍历、哈希槽位计算、协议包循环解析，每一点CPU周期都很宝贵。
- 需要原子操作的场景：并发编程里用CAS配合位标志，比加锁快得多；内核里的同步系列操作大量依赖位图。
我的建议是，先把业务逻辑写对、写清楚，然后上profiler找热点。如果发现某个函数确实是瓶颈，而这瓶颈确实和位运算有关，再用位运算优化，并且留下注释说明为什么这么写。为了炫技而把整个项目写得谁也看不懂，那不是高手风范，是给自己埋雷。
最后再提一个真实经历：有一次我优化一个高频消息队列，里面有个“消息是否已被消费”的标记，本来用bool数组，每个消费者一个标记，要占好几MB内存。后来改成位图，内存降到不到原来的十分之一，判断时的分支也少了一截，整个服务吞吐量立刻上来了。那次之后我对位运算符的实际应用场景有了更深体会：它不是面试题里的一道花活，而是贴近硬件、贴近数据结构的表达方式，只要你写C语言、写底层、写高性能服务，它就永远绕不开。
