1. 从一道经典的面试题说起

如果你在面试中被问到“如何不借助第三个变量，交换两个整型变量的值？”，你会怎么回答？很多有一定基础的开发者会立刻想到使用加减法：a = a + b; b = a - b; a = a - b;。这个方法确实可行，但它有一个潜在的隐患——整数溢出。当a和b的值都很大，接近数据类型的表示上限时，a + b的操作可能导致溢出，从而引发未定义行为或得到错误的结果。

一个更优雅、更安全，且同样不借助临时变量的解法，是使用我们今天要深入探讨的主角：异或操作符（^）。它的交换代码是这样的：a = a ^ b; b = a ^ b; a = a ^ b;。我第一次看到这段代码时，感觉像在看魔术，几个简单的操作后，两个变量的值就互换了，而且完全规避了溢出的风险。这个“魔术”的背后，正是异或操作符一系列精妙而强大的性质在支撑。

异或操作符是C语言位操作符家族中的核心成员之一，它的行为看似简单，却蕴含着深刻的逻辑和广泛的应用场景。从基础的加密校验、图形处理，到算法优化、底层驱动开发，乃至一些巧妙的面试题和竞赛题，都能见到它的身影。理解异或，不仅仅是记住它的真值表，更是要掌握其背后的数学原理和思维模式。在接下来的内容里，我将带你彻底拆解这个操作符，从它的定义、性质讲起，并通过一系列由浅入深的例题，让你不仅“会用”，更能“懂为什么这么用”，最终能灵活地将它运用到你的代码中。

2. 异或操作符的本质与核心性质

在C语言中，异或操作符^是一个二元位操作符。它的运算规则是：当两个操作数的对应位不同时，结果为1；相同时，结果为0。这个定义用一句话概括就是“相同为0，不同为1”。

我们可以通过一个简单的例子来直观感受：

unsigned char a = 0b0101 1101; // 十进制 93 unsigned char b = 0b1011 0010; // 十进制 178 unsigned char c = a ^ b; // 进行异或运算

我们来逐位计算c：

a: 0 1 0 1 1 1 0 1 b: 1 0 1 1 0 0 1 0 c: 1 1 1 0 1 1 1 1

计算过程是：从最高位（最左边）开始，0和1不同，所以c的最高位是1；接下来1和0不同，得1；0和1不同，得1；1和1相同，得0；1和0不同，得1；1和0不同，得1；0和1不同，得1；1和0不同，得1。最终c的二进制是0b1110 1111，即十进制239。

仅仅知道定义是远远不够的。异或操作符之所以强大，源于它以下几个至关重要的数学性质，这些性质是理解和运用它的基石：

性质一：交换律a ^ b == b ^ a这意味着操作数的顺序不影响结果。这和加法、乘法是一样的。

性质二：结合律(a ^ b) ^ c == a ^ (b ^ c)这意味着我们可以将多个数连续异或，而不必关心结合的次序。这个性质在解决一些数组问题时非常关键。

性质三：自反性（或归零律）a ^ a == 0任何数与自身异或，结果为零。这是异或操作最独特的性质之一，也是很多巧妙算法的基础。你可以把它理解为“自己抵消了自己”。

性质四：恒等律a ^ 0 == a任何数与0异或，等于它本身。0在这里扮演了“单位元”的角色。

性质五：可逆性（由自反性和结合律推导）如果c = a ^ b，那么a = c ^ b，同时b = c ^ a。 这个性质是那个“交换变量”魔术的核心原理。证明很简单：因为c = a ^ b，那么c ^ b = (a ^ b) ^ b = a ^ (b ^ b) = a ^ 0 = a。

注意：异或操作符的优先级在C语言中是比较低的，仅高于逻辑与&&、逻辑或||和条件运算符。在实际编码中，为了清晰和避免错误，强烈建议对异或表达式加上括号，除非你非常确定运算顺序。例如if ((a ^ b) & mask)就比if (a ^ b & mask)清晰安全得多，因为后者的&优先级高于^。

理解了这些性质，我们就能看穿文章开头那个变量交换的“魔术”了。让我们一步步拆解：

1. a = a ^ b;// 此时a变成了原来的a和b的“混合体”（记为a'），b还是原来的b。
2. b = a ^ b;// 代入上一步的a'，即b = (a ^ b) ^ b。根据结合律和自反性：(a ^ b) ^ b = a ^ (b ^ b) = a ^ 0 = a。所以，b被成功赋值为原来的a。
3. a = a ^ b;// 注意，此时的a是a'（即a^b），b已经是原来的a。所以a = (a ^ b) ^ a。同样根据交换律和自反性：(a ^ b) ^ a = b ^ (a ^ a) = b ^ 0 = b。于是，a被赋值为原来的b。

整个过程如行云流水，没有溢出风险，只使用了最基本的位运算，效率极高。这就是异或之美。

3. 基础应用：校验、标记与简单加密

掌握了核心性质，我们就可以看看异或在一些基础但实用的场景中是如何发挥作用的。这些场景往往直接利用了异或的可逆性和自反性。

3.1 数据校验与简单错误检测

在一些简单的通信协议或数据存储中，我们可能需要一个快速的方法来检查一小段数据在传输或存储后是否发生了变化。异或校验（XOR Checksum）就是一种轻量级的方法。

其原理是：将数据块中的所有字节依次进行异或运算，得到一个单字节的校验和。接收方或读取方重新计算一次校验和，与发送方存储的校验和进行比较。如果相同，则认为数据大概率正确（注意，异或校验能力较弱，多位错误可能相互抵消导致校验通过）。

#include <stdint.h> uint8_t calculate_xor_checksum(const uint8_t *data, size_t length) { uint8_t checksum = 0; // 初始化为0，因为 a ^ 0 = a for (size_t i = 0; i < length; ++i) { checksum ^= data[i]; // 连续异或所有字节 } return checksum; } // 示例用法 uint8_t my_data[] = {0x01, 0x02, 0x03, 0x04, 0x05}; uint8_t checksum = calculate_xor_checksum(my_data, 5); // 假设我们将 my_data 和 checksum 一起发送或存储 // ... // 接收方或读取方 uint8_t recalculated_checksum = calculate_xor_checksum(my_data, 5); if (recalculated_checksum == checksum) { // 数据可能完好 } else { // 数据一定发生了改变 }

这里利用了异或的结合律，无论数据字节的顺序如何，只要内容不变，最终异或的结果就是唯一的。初始化为0是因为恒等律a ^ 0 = a，使得第一个字节能正常参与运算。

3.2 标志位的切换（Toggle）

在嵌入式系统或图形界面开发中，我们经常需要控制一个二值状态（如LED灯的亮灭、某个功能的开关）。使用异或可以极其简洁地实现状态的“翻转”。

// 假设我们用一个整数的某一位（比如第3位，从0开始计数）来控制一个状态 #define FLAG_MASK (1 << 3) // 二进制 0000 1000 uint32_t status_register = 0; // 初始状态 // 函数：翻转（Toggle）标志位 void toggle_flag(uint32_t *reg) { *reg ^= FLAG_MASK; // 核心操作 } // 使用 toggle_flag(&status_register); // 第3位从0变为1（打开） toggle_flag(&status_register); // 第3位从1变为0（关闭） toggle_flag(&status_register); // 再次从0变为1

为什么^=能实现翻转？我们分析一下：对于目标位（在FLAG_MASK中为1的位），如果status_register中原先为0，那么0 ^ 1 = 1，位被置1；如果原先为1，那么1 ^ 1 = 0，位被清0。而对于FLAG_MASK中为0的位，根据恒等律x ^ 0 = x，其他位保持不变。这种方法比先判断再设置（if-else加|=或&=）要简洁高效得多。

3.3 基于异或的简单对称加密

利用异或的可逆性(a ^ k) ^ k = a，我们可以实现一个最简单的对称加密/解密算法。k就是密钥。

void xor_crypt(char *data, size_t len, char key) { for (size_t i = 0; i < len; ++i) { data[i] ^= key; // 加密：明文 ^ 密钥 -> 密文 // 解密：密文 ^ 密钥 -> 明文 （因为 (data[i]^key)^key = data[i]） } }

这个算法非常脆弱，仅供学习原理使用。因为单字节密钥空间太小，且明文模式容易暴露。但它清晰地展示了异或作为可逆运算的特性：同一个函数，用同样的密钥运行两次，就能恢复原始数据。更复杂的流密码（如RC4）的核心思想也包含了异或运算。

4. 算法与数据结构中的妙用

异或操作在算法领域，尤其是在空间复杂度优化方面，有着一些非常巧妙的应用。这些题目常常出现在技术面试中，考察的是对异或性质的深刻理解。

4.1 找出“落单”的数字（LeetCode 136）

这是最经典的异或算法题：给定一个非空整数数组，其中除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。要求线性时间复杂度，并且不使用额外空间。

暴力解法（双层循环）时间复杂度是O(n²)，使用哈希表记录次数需要O(n)额外空间。而利用异或的性质，我们可以给出一个O(n)时间，O(1)空间的完美解法。

核心思路：利用异或的交换律、结合律和自反性。

• 交换律和结合律保证了我们可以无视数字顺序，任意两两异或。
• 自反性a ^ a = 0保证了所有出现两次的数字，两两异或后会变成0。
• 恒等律a ^ 0 = a保证了0与那个只出现一次的数字异或，结果就是该数字本身。

因此，我们只需要将数组中所有的数字从头到尾异或一遍，最终的结果就是那个“落单”的数字。

int singleNumber(int* nums, int numsSize) { int result = 0; for (int i = 0; i < numsSize; ++i) { result ^= nums[i]; // 连续异或所有元素 } return result; }

让我们用一个例子[4, 1, 2, 1, 2]来验证：result初始为0。

1. 0 ^ 4 = 4
2. 4 ^ 1 = 5(二进制 0100 ^ 0001 = 0101)
3. 5 ^ 2 = 7(0101 ^ 0010 = 0111)
4. 7 ^ 1 = 6(0111 ^ 0001 = 0110)
5. 6 ^ 2 = 4(0110 ^ 0010 = 0100) 最终结果是4。从过程看，1和1异或、2和2异或都抵消为0，最终剩下0和4异或，得到4。

这个解法有一个非常重要的前提：其他数字必须恰好出现两次。如果出现次数是其他偶数次，结论依然成立（因为偶数次自身异或最终也是0）。但如果出现奇数次（比如三次），这个方法就失效了。

4.2 进阶：找出两个“落单”的数字（LeetCode 260）

问题升级：一个数组里，除了两个数字各出现一次外，其他数字都出现了两次。找出这两个数字。

思路不能简单地全部异或了，因为全部异或的结果xor_all等于这两个目标数a和b的异或值，即xor_all = a ^ b。我们需要从这个混合信息中分离出a和b。

关键洞察：既然a和b不相等，那么xor_all = a ^ b一定不等于0。也就是说，在xor_all的二进制表示中，至少有一位是1。这一位为1，意味着a和b在这一位上的值是不同的（一个为0，一个为1）。

我们可以利用这个不同的位，将原数组划分成两个子数组。划分标准是：所有数字中，该位为1的为一组，该位为0的为另一组。这样做的结果是：

1. a和b必然被分到不同的组（因为他们在这一位不同）。
2. 其他出现两次的数字，相同的两个数字在该位的值一定是相同的，所以它们一定会被分到同一组。

于是，问题就转化为了在两个子数组中，分别寻找“只出现一次的数字”（即LeetCode 136的问题）。我们对每个子数组全部异或，得到的结果就是a和b。

void findTwoSingleNumbers(int* nums, int numsSize, int* result1, int* result2) { // 1. 异或所有数，得到 xor_all = a ^ b int xor_all = 0; for (int i = 0; i < numsSize; ++i) { xor_all ^= nums[i]; } // 2. 找到 xor_all 中任意一个为1的位（这里找最低位的1） // 技巧：xor_all & (-xor_all) 可以保留最低位的1，其余位置0 // 例如：xor_all = 6 (0110), -xor_all = -6 (补码: ...1010)， 0110 & 1010 = 0010 int diff_bit = xor_all & (-xor_all); // 3. 根据 diff_bit 将数组分成两组并分别异或 *result1 = 0; *result2 = 0; for (int i = 0; i < numsSize; ++i) { if (nums[i] & diff_bit) { // 该位为1的组 *result1 ^= nums[i]; } else { // 该位为0的组 *result2 ^= nums[i]; } } // 循环结束后，*result1 和 *result2 就是我们要找的两个数 }

这个解法同样满足O(n)时间和O(1)空间的要求。它巧妙地将一个复杂问题，通过异或的性质转化为了两个已解决的简单问题。

4.3 内存高效的双向链表——XOR Linked List

这是一个非常经典的、利用异或来实现的“炫技”型数据结构，虽然在实际工程中极少使用（因为可读性和调试性差），但它对于理解异或的“可逆”特性非常有帮助。

在普通双向链表中，每个节点需要存储prev和next两个指针。XOR链表的思想是：只用一个指针字段both，它存储的是前驱节点地址和后继节点地址的异或值。即both = prev_address ^ next_address。

那么如何遍历呢？

• 假设我们从头节点A开始，它没有前驱，所以A.both = 0 ^ address_of_B。
• 我们知道A的地址和A.both，想要得到B的地址：address_of_B = A.both ^ 0。
• 现在到了节点B。我们知道B的前驱是A。想要得到B的后继C的地址：address_of_C = B.both ^ address_of_A。
• 以此类推。在遍历过程中，我们总是需要知道当前节点和它的前一个节点，才能计算出下一个节点。

typedef struct XorNode { int data; struct XorNode* both; // 存储 prev ^ next } XorNode; // 在链表末尾添加一个新节点 (需要知道尾节点及其前驱) void xor_list_add(XorNode* tail, XorNode* prev, int new_data) { XorNode* new_node = (XorNode*)malloc(sizeof(XorNode)); new_node->data = new_data; // 新节点的 both 是 (尾节点地址 ^ 0)，因为它的后继暂时是NULL new_node->both = tail; // 更新原尾节点的 both 指针 // 原尾节点的 both 原为： prev_of_tail ^ NULL // 现在需要更新为： prev_of_tail ^ new_node // 根据异或性质： new_both = (prev_of_tail ^ NULL) ^ NULL ^ new_node // 因为 tail->both = prev_of_tail ^ NULL， 且 NULL ^ new_node = new_node // 所以： tail->both = tail->both ^ new_node; if (tail != NULL) { tail->both = (XorNode*)((uintptr_t)(tail->both) ^ (uintptr_t)new_node); } } // 正向遍历 (需要从头节点和NULL开始) void xor_list_traverse_forward(XorNode* head) { XorNode* current = head; XorNode* prev = NULL; XorNode* next; while (current != NULL) { printf("%d ", current->data); // 计算下一个节点地址： next = current->both ^ prev next = (XorNode*)((uintptr_t)(current->both) ^ (uintptr_t)prev); prev = current; current = next; } printf("\n"); }

注意：这里使用了uintptr_t来进行指针与整数的转换，因为异或操作符^不能直接用于指针类型。这种转换需要包含<stdint.h>头文件。

XOR链表将两个指针的空间压缩为一个，体现了异或的“存储压缩”和“信息还原”能力。但它牺牲了代码的直观性和随机访问节点的能力，是一种典型的“时间换空间”或“脑力换空间”的权衡，在实际开发中需要谨慎评估是否值得使用。

5. 图形处理与游戏开发中的位操作

在图形编程和游戏开发等对性能要求极高的领域，异或操作因其直接操作内存位、速度极快的特点，曾经有一些特定的应用场景。虽然现代高级图形API（如OpenGL, DirectX）和硬件加速已使其部分应用成为历史，但理解其原理仍有价值。

5.1 经典的光标反色与橡皮擦效果

在早期的图形用户界面（GUI）和绘图软件中，为了实现一个不破坏背景、移动时光标可见的“十字准星”或“矩形选框”，经常使用异或模式绘图。

其原理是：将光标图案用异或方式画到屏幕上。第一次绘制时，屏幕像素的颜色值与光标图案颜色值异或，产生一个新的颜色，使得光标可见。当光标需要移动到新位置时，在原位置用同样的异或操作再画一次。根据自反性(pixel ^ pattern) ^ pattern = pixel，第一次异或绘制的结果，再与同样的图案异或一次，就完全恢复了屏幕原始的像素颜色，仿佛光标被“擦除”了，而且没有留下任何痕迹。然后在新位置再次执行异或绘制，光标就在新位置显示出来。

// 伪代码示意 void draw_xor_cursor(int x, int y, const uint32_t* cursor_pattern) { // 假设 screen_buffer 是屏幕帧缓冲区的指针 uint32_t* screen_ptr = &screen_buffer[y * SCREEN_WIDTH + x]; for (int row = 0; row < CURSOR_HEIGHT; ++row) { for (int col = 0; col < CURSOR_WIDTH; ++col) { // 异或绘图：屏幕像素 ^ 光标图案像素 screen_ptr[col] ^= cursor_pattern[row * CURSOR_WIDTH + col]; } screen_ptr += SCREEN_WIDTH; // 移动到下一行 } } // 使用：先画一次显示光标 draw_xor_cursor(old_x, old_y, cursor_pattern); // 移动光标前，在原位置再画一次，擦除光标 draw_xor_cursor(old_x, old_y, cursor_pattern); // 在新位置画光标 draw_xor_cursor(new_x, new_y, cursor_pattern);

这种方法实现了零残留的光标移动，效率很高。在现代系统中，这种技术多被硬件光标或双缓冲等技术取代，但其思想在需要快速、临时覆盖显示的场合仍有参考意义。

5.2 颜色值的快速切换与特效

在一些颜色深度有限的系统（如16色、256色模式）中，可以利用异或快速实现颜色反转等简单特效。例如，如果一个像素的颜色索引值是color_index，那么color_index ^ 0x0F（假设调色板有16种颜色）可能会得到一种对比强烈的颜色，实现“反色”或“高亮”效果。这比去查一个颜色映射表要快得多。

在游戏开发中，早期为了实现角色的“闪烁无敌”效果（受到伤害后角色短暂闪烁），有时也会采用每隔几帧就用异或操作重绘角色部分的方式，快速地在两种视觉状态间切换。

6. 深入底层：异与硬件与汇编

要真正理解异或操作的效率，我们需要再往下走一层，看看它在硬件和汇编层面是怎样的。在绝大多数现代CPU的指令集中，异或（XOR）都是一条非常基础且快速的指令。它直接在算术逻辑单元（ALU）中对寄存器的位进行操作，通常在一个时钟周期内就能完成。

6.1 汇编层面的异或

在x86汇编中，异或指令是XOR。它有几个常见用途：

1. 快速将寄存器清零：XOR EAX, EAX。这条指令将EAX寄存器与自己异或，根据自反性，结果必然是0。这条指令比MOV EAX, 0更短（机器码更少），在某些旧的或优化的编译器中，被认为是将寄存器置零的最快方式。
2. 比较两个值是否相等：CMP指令内部可能用到异或运算来比较两个操作数是否相等。如果a ^ b == 0，则说明a和b的每一个位都相同，即a == b。
3. 交换寄存器值：和我们高级语言里的技巧一样，三条XOR指令可以不借助第三个寄存器交换两个寄存器的值。

   ; 假设 EAX = a, EBX = b XOR EAX, EBX ; EAX = a ^ b XOR EBX, EAX ; EBX = b ^ (a ^ b) = a XOR EAX, EBX ; EAX = (a ^ b) ^ a = b ; 现在 EAX = b, EBX = a

6.2 编译器优化与异或

现代的C/C++编译器非常智能，它们会识别代码中的特定模式，并尝试用更高效的指令来替代。例如，对于a = a ^ b; b = a ^ b; a = a ^ b;这样的变量交换，编译器在开启优化后，可能会直接使用一条XCHG（交换）指令（如果CPU支持且上下文允许），或者使用三个MOV指令通过寄存器中转，这通常比三条XOR指令更快，因为XOR有数据依赖关系（后一条指令必须等前一条指令的结果），而MOV指令可以更好地被流水线处理。

因此，在高级语言中，我们不应该为了“炫技”而刻意使用异或交换变量。对于现代编译器，std::swap或使用临时变量的写法通常能产生最优的汇编代码。我们学习异或交换的原理，是为了理解其背后的位运算思想，而不是为了将其作为日常的最佳实践。

6.3 在嵌入式开发中的实际考量

在资源极度受限的嵌入式开发中，异或操作仍然有其用武之地。除了之前提到的标志位切换、简单校验和外，在一些自定义的轻量级通信协议中，可能会用异或来生成帧校验序列。在驱动某些特定硬件时，可能需要通过异或来翻转某个控制引脚的电平（如果IO口支持位操作）。

但更重要的是，嵌入式程序员必须对数据的二进制表示有深刻理解。异或操作是直接基于二进制的，当你需要从一段打包的数据中提取某个位域，或者将几个位域组合成一个字节时，结合移位（<<,>>）和位与（&）、位或（|）操作，异或也能参与其中，完成一些复杂的位掩码操作。例如，要确保一个字节的某些位被设置为特定的值，而其他位保持不变，常用的模式是：先使用&和掩码清除那些位，然后使用|或^（如果目标值是由翻转产生）来设置它们。

7. 避坑指南与性能考量

尽管异或操作功能强大，但在实际使用中也有一些“坑”需要留意。忽略这些细节可能导致难以调试的bug或性能损失。

7.1 陷阱一：运算符优先级

这是最常出错的地方之一。C语言中位操作符的优先级普遍低于比较操作符和算术操作符。

int a = 1, b = 2, c = 3; int result = a ^ b & c; // 等价于 a ^ (b & c)， 结果是 1 ^ (2 & 3) = 1 ^ 2 = 3 int expected = (a ^ b) & c; // 如果你想要的是这个，结果是 (1^2)&3 = 3&3=3 (这里巧合相等) int another = a ^ b == c; // 等价于 a ^ (b == c)， 因为 `==` 优先级高于 `^`！结果是 1 ^ (2==3) = 1 ^ 0 = 1

最佳实践：只要不是最简单的单个变量操作，总是给位操作表达式加上括号。(a ^ b) & c和a ^ (b & c)的意义完全不同，清晰的括号能避免歧义和错误。

7.2 陷阱二：对浮点数使用位操作符

C语言标准规定，位操作符（~,&,|,^,<<,>>）的操作数必须是整数类型。对float或double使用位操作符是未定义行为。编译器可能会报错，也可能产生毫无意义的结果。

float f1 = 3.14f, f2 = 2.71f; // int bad = (int)f1 ^ (int)f2; // 这实际上是合法的，因为对(int)3和(int)2操作，但意义已变 // int very_bad = f1 ^ f2; // 非法/未定义行为

如果你需要对浮点数的底层二进制表示进行操作（比如快速比较、特殊值处理），应该使用memcpy或union（注意类型双关在C99后是未定义行为，但在许多编译器中作为扩展支持）将其转换为相同大小的整数类型（如float转uint32_t），然后再进行位操作。

#include <string.h> #include <stdint.h> int float_bits_equal(float a, float b) { uint32_t ia, ib; // 使用 memcpy 避免严格别名规则问题，这是标准且安全的方法 memcpy(&ia, &a, sizeof(a)); memcpy(&ib, &b, sizeof(b)); return ia == ib; // 直接比较二进制位是否完全相同 }

7.3 陷阱三：有符号整数的右移与异或

对于有符号整数，C语言标准规定，对其使用右移操作符>>的结果是实现定义的。大多数编译器（如GCC, Clang, MSVC）会对有符号整数进行算术右移，即高位补符号位（负数补1，正数补0）。这与无符号整数的逻辑右移（高位总是补0）不同。 当异或操作与有符号整数的移位结合时，可能会产生意想不到的结果，特别是涉及符号扩展时。

int8_t x = -8; // 二进制补码：1111 1000 int8_t y = x >> 2; // 算术右移两位：结果可能是 1111 1110 (即 -2) int8_t z = x ^ y; // 结果依赖于 y 的具体值

建议：在进行低层位操作时，尽量使用无符号整数类型（unsigned int,uint8_t,uint32_t等）。它们的行为是明确定义的：移位操作总是逻辑移位，溢出行为是模运算，更适合进行位操作。

7.4 性能考量：并非总是最快

虽然单条异或指令很快，但在算法层面，我们需要从整体评估。

• 交换变量：如前所述，现代编译器对临时变量交换的优化可能更好。异或交换引入了三次数据依赖，可能阻碍指令级并行。
• 清零寄存器：xor eax, eax在x86上确实是清零寄存器的惯用优化方法，编译器深知这一点。但在高级语言中，你写a = 0，编译器自然会为你选择最优的实现，无需手动写成a ^= a（后者可能让代码更难读）。
• 算法选择：异或算法（如找单身狗）在特定约束（O(1)空间）下是优美的。但如果空间不是问题，使用哈希表计数可能更直观，也更容易被其他开发者理解。在追求极致性能的场合，还需要考虑CPU缓存、分支预测等因素，异或算法由于没有分支，通常表现很稳定。

核心原则：可读性优先。除非你正在编写对性能极度敏感的底层库、嵌入式代码，或者正在解决一个明确的、需要节省内存的算法问题，否则应优先选择意图更清晰的写法。使用异或等位运算时，务必加上清晰的注释，解释这样做的原因和背后的逻辑。毕竟，代码是写给人看的，顺便让机器执行。