在编程中，不使用额外变量（临时变量）时，可以通过加减法交换两个变量的值。这种方法的核心思想是利用数学中的“和差关系”实现值的交换。以下是具体实现方式、原理及注意事项。

一、加减法交换变量的原理

假设变量 a 和 b 存储初始值，通过以下步骤交换：

1. 求和：将 a 和 b 的和存入 a 中，即 a = a + b。
2. 求差（获取原 b 的值）：用新的 a（和）减去原 b 的值，得到原 a 的值，并存入 b 中，即 b = a - b。
3. 求差（获取原 a 的值）：用新的 a（和）减去新的 b（原 a 的值），得到原 b 的值，并存入 a 中，即 a = a - b。

数学推导：
设初始值为 a = x，b = y：

• 第一步：a = x + y
• 第二步：b = (x + y) - y = x（此时 b 变为原 a 的值 x）
• 第三步：a = (x + y) - x = y（此时 a 变为原 b 的值 y）
  最终实现 a 和 b 的值交换。

二、代码示例（以整数为例）

1. C++ 实现

#include <iostream>
using namespace std;

int main() {
    int a = 5, b = 10;
    
    cout << "交换前：a = " << a << ", b = " << b << endl;
    
    // 加减法交换步骤
    a = a + b;   // a = 5 + 10 = 15
    b = a - b;   // b = 15 - 10 = 5（原 a 的值）
    a = a - b;   // a = 15 - 5 = 10（原 b 的值）
    
    cout << "交换后：a = " << a << ", b = " << b << endl;
    return 0;
}

推荐做法：使用临时变量或语言内置的交换函数（如 C++ 的 std::swap），以确保代码的健壮性和可维护性。

#include <iostream>
#include <algorithm>
using namespace std;
int main() {
    int a = 5;
    int b = 10;

    cout << "交换前: a = " << a << ", b = " << b << endl;

    swap(a, b);

    cout << "交换后: a = " << a << ", b = " << b << endl;

    return 0;
}

按位异或运算符 ^ 确实能够在不借助额外变量的情况下交换两个变量的值。下面会从原理、代码示例、注意事项等方面详细阐述。

原理

按位异或运算符 ^ 具备如下特性：

1. 任何数与自身进行异或操作，结果为 0，即 a ^ a = 0。
2. 任何数与 0 进行异或操作，结果为其本身，即 a ^ 0 = a。
3. 异或运算满足交换律和结合律，即 a ^ b ^ a = a ^ a ^ b = b。

代码示例

下面是用不同编程语言实现使用按位异或运算符交换两个变量值的代码：

#include <iostream>
int main() {
    int a = 5;
    int b = 10;

    // 交换变量的值
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;

    std::cout << "交换后 a 的值: " << a << std::endl;
    std::cout << "交换后 b 的值: " << b << std::endl;

    return 0;
}

代码解释

以 a = 5（二进制 0101）和 b = 10（二进制 1010）为例：

1. 第一步：a = a ^ b a 变为 0101 ^ 1010 = 1111。
2. 第二步：b = a ^ b 此时 a 为 1111，b 为 1010，则 b 变为 1111 ^ 1010 = 0101，也就是原来 a 的值。
3. 第三步：a = a ^ b 此时 a 为 1111，b 为 0101，则 a 变为 1111 ^ 0101 = 1010，也就是原来 b 的值。

注意事项

• 性能方面：在现代编译器和硬件环境下，使用临时变量交换变量值通常在性能上更优，因为编译器对临时变量交换的优化更好。
• 类型问题：该方法仅适用于整数类型的变量，因为按位异或运算符是针对二进制位进行操作的。
• 安全性：如果 a 和 b 引用的是同一个内存地址（即 a 和 b 是同一个变量），那么使用这种方法会导致变量的值变为 0。例如：

a = 5
a = a ^ a
a = a ^ a
a = a ^ a
print(a)  # 输出 0

综上所述，按位异或运算符 ^ 可以用于交换两个变量的值，但在实际使用中要根据具体情况考虑是否采用。

答案

1. √
2. ×
3. √
4. √
5. ×
6. ×
7. √
8. ×

解析

1. 按位或运算符特性： 按位或运算符 | 的规则就是对两个操作数的对应二进制位进行比较，只要两个对应位中有一个为 1，结果位就为 1。所以该说法正确。
2. 左移运算符的填充规则： 左移运算符 << 会将操作数的二进制位向左移动，右边空出的位用 0 填充，而不是左边。所以该说法错误。
3. 正数按位取反结果： 在计算机中，整数通常以补码形式存储。对于正数，按位取反后符号位会变为 1，在补码表示下，符号位为 1 代表负数。例如，正数 5（二进制 0101），按位取反后是 -6（补码表示）。所以对一个正数进行按位取反操作后，结果一定是负数，该说法正确。
4. 按位异或交换变量值： 利用按位异或运算符 ^ 的特性可以在不使用额外变量的情况下交换两个变量的值。代码逻辑如下：

a = a ^ b;
b = a ^ b;
a = a ^ b;

通过上述三步操作可以实现 a 和 b 值的交换。所以该说法正确。 5. 右移运算符对不同类型数的处理： 右移运算符 >> 对于有符号数和无符号数的处理方式不同。对于无符号数，右移时左边空出的位用 0 填充；对于有符号数，右移时左边空出的位用符号位填充（正数补 0，负数补 1）。所以该说法错误。 6. 按位异或运算结果： 已知 a = 3（二进制 0011），b = 5（二进制 0101），按位异或运算符 ^ 是对应位不同结果位为 1，相同则为 0。所以 a ^ b 即 0011 ^ 0101 = 0110，二进制 0110 转换为十进制是 6。所以该说法正确。 7. 按位与判断偶数： 一个整数的二进制表示中，最低位为 0 时是偶数，最低位为 1 时是奇数。按位与运算符 & 可以用于提取特定位。num & 1 会将 num 的二进制表示与 1（二进制 0001）进行按位与运算，如果结果为 0，说明 num 的最低位是 0，即 num 是偶数。所以该说法正确。 8. 位运算符与算术运算符优先级： 位运算符的优先级并非都高于算术运算符。例如，算术运算符中的乘法 *、除法 /、取模 % 的优先级高于位运算符中的按位与 &、按位或 | 等。所以该说法错误。

答案

1. B
2. D
3. D
4. C
5. B
6. B
7. A
8. A

解析

1. 按位与运算符：
   • | 是按位或运算符，它会对两个操作数的对应二进制位进行比较，只要两个对应位中有一个为 1，结果位就为 1。
   • & 是按位与运算符，它对两个操作数的对应二进制位进行比较，只有当两个对应位都为 1 时，结果位才为 1。
   • ^ 是按位异或运算符，若两个对应位不同，结果位为 1，若相同则结果位为 0。
   • ~ 是按位取反运算符，它会对操作数的每一个二进制位取反。所以答案选 B。
2. 按位或运算结果：
   • a = 5，二进制是 0101；b = 3，二进制是 0011。
   • 按位或运算规则是只要对应位有一个为 1 结果位就为 1，所以 0101 | 0011 = 0111，二进制 0111 转换为十进制是 7。答案选 D。
3. 按位取反操作结果：
   • 按位取反是对操作数的每一个二进制位取反。对于正数，取反后是负数；对于负数，取反后是正数。而且结果的绝对值与原数也不相同。例如，若 a = 5（二进制 0101），~a 是 -6（二进制补码表示）。所以以上说法都不对，选 D。
4. 左移运算符的作用：
   • 左移运算符 << 会将操作数的二进制位向左移动指定的位数，右边空出的位用 0 填充。
   • 选项 A 描述的是右移运算符 >> 的作用；选项 B 中右边空出位用 1 填充是错误的；选项 D 描述的是按位取反运算符 ~ 的作用。所以答案是 C。
5. 右移运算结果：
   • x = 10，二进制是 1010。
   • 右移运算符 >> 将操作数的二进制位向右移动指定的位数，对于正数，左边空出的位用 0 填充。x >> 2 即 1010 右移 2 位得到 0010，二进制 0010 转换为十进制是 2。所以选 B。
6. 按位异或运算符的特点：
   • 按位异或运算符 ^ 对两个操作数的对应二进制位进行比较，若两个对应位不同，结果位为 1，若相同则结果位为 0。
   • 选项 A 描述错误；选项 C 是按位或运算符 | 的特点；选项 D 是按位与运算符 & 的特点。所以答案选 B。
7. 等价于乘以 4 的表达式：
   • 左移运算符 << 有乘以 2 的幂次的效果，左移 n 位相当于乘以 2 的 n 次方。
   • num << 2 相当于 num 乘以 2^2 即乘以 4。
   • num >> 2 是将 num 除以 4；num & 4 是按位与运算，用于提取特定位；num | 4 是按位或运算。所以选 A。
8. 按位与运算结果的十进制表示：
   • m = 15，二进制是 1111；n = 7，二进制是 0111。
   • 按位与运算规则是对应位都为 1 结果位才为 1，所以 1111 & 0111 = 0111，二进制 0111 转换为十进制是 7。答案选 A。

在 C++ 里，运算符优先级规定了表达式中运算符执行的先后顺序。下面将详细介绍常见运算符的优先级。

优先级顺序

C++ 运算符优先级从高到低大致可分为以下几个等级：

1. 括号类

• 括号 ()：用于改变表达式的运算顺序，具有最高优先级。在括号内的表达式会优先计算。

#include <iostream>
int main() {
    int result = (2 + 3) * 4;
    std::cout << result << std::endl;
    return 0;
}

此例中，先计算括号内的 2 + 3，再将结果乘以 4。

2. 一元运算符

• 逻辑非 !：对操作数的逻辑值取反。
• 按位取反 ~：对操作数的每一个二进制位取反。
• 自增 ++ 和 自减 --：分为前置和后置，前置先改变变量的值再使用，后置先使用变量的值再改变。
• 正号 + 和 负号 -：表示数值的正负。

#include <iostream>
int main() {
    int a = 5;
    int b = -a;
    int c = !a;
    std::cout << b << " " << c << std::endl;
    return 0;
}

这里，-a 取 a 的负值，!a 对 a 的逻辑值取反。

3. 算术运算符

• 乘法 *、除法 / 和 取模 %：这些运算符优先级相同，按照从左到右的顺序计算。
• 加法 + 和 减法 -：优先级低于乘除和取模，同样按从左到右的顺序计算。

#include <iostream>
int main() {
    int result = 5 + 3 * 2;
    std::cout << result << std::endl;
    return 0;
}

此例中，先计算 3 * 2，再将结果与 5 相加。

4. 移位运算符

• 左移 << 和 右移 >>：将操作数的二进制位向左或向右移动指定的位数。

#include <iostream>
int main() {
    int a = 5;
    int b = a << 2;
    std::cout << b << std::endl;
    return 0;
}

这里，a 的二进制位向左移动 2 位。

5. 关系运算符

• 小于 <、小于等于 <=、大于 > 和 大于等于 >=：用于比较两个操作数的大小关系。
• 等于 == 和 不等于 !=：用于判断两个操作数是否相等。

#include <iostream>
int main() {
    int a = 5;
    int b = 3;
    bool result = a > b;
    std::cout << std::boolalpha << result << std::endl;
    return 0;
}

此例中，比较 a 和 b 的大小。

6. 位运算符

• 按位与 &：对两个操作数的对应二进制位进行与运算。
• 按位异或 ^：对两个操作数的对应二进制位进行异或运算。
• 按位或 |：对两个操作数的对应二进制位进行或运算。

#include <iostream>
int main() {
    int a = 5;
    int b = 3;
    int result = a & b;
    std::cout << result << std::endl;
    return 0;
}

这里，对 a 和 b 进行按位与运算。

7. 逻辑运算符

• 逻辑与 &&：只有当两个操作数的逻辑值都为真时，结果才为真。
• 逻辑或 ||：只要两个操作数的逻辑值中有一个为真，结果就为真。

#include <iostream>
int main() {
    int a = 5;
    int b = 3;
    bool result = (a > 0) && (b < 5);
    std::cout << std::boolalpha << result << std::endl;
    return 0;
}

此例中，使用逻辑与运算符判断两个条件是否同时成立。

8. 条件运算符（三元运算符）

• ? :：根据条件表达式的值选择两个表达式中的一个进行计算。

#include <iostream>
int main() {
    int a = 5;
    int b = 3;
    int result = (a > b) ? a : b;
    std::cout << result << std::endl;
    return 0;
}

这里，如果 a > b 为真，结果为 a，否则为 b。

9. 赋值运算符

• =、+=、-=、*=、/=、%= 等：用于给变量赋值或进行复合赋值操作。

#include <iostream>
int main() {
    int a = 5;
    a += 3;
    std::cout << a << std::endl;
    return 0;
}

此例中，a += 3 等价于 a = a + 3。

10. 逗号运算符

• ,：从左到右依次计算逗号分隔的表达式，结果为最后一个表达式的值。

#include <iostream>
int main() {
    int a = (1, 2, 3);
    std::cout << a << std::endl;
    return 0;
}

这里，表达式 (1, 2, 3) 的结果为 3。

注意事项

• 为了让代码更具可读性，避免因优先级问题引发错误，建议使用括号来明确运算顺序。
• 运算符优先级只是规定了表达式中运算符的执行顺序，在实际编程中，还需要考虑运算符的结合性（从左到右或从右到左）。

你可以参考下面的表格来更清晰地查看运算符优先级：

优先级	运算符	结合性
1	::	从左到右
2	() [] -> . ++ --（后缀）
3	++ --（前缀） + - ! ~ (type) * & sizeof alignof	从右到左
4	.* ->*	从左到右
5	* / %
6	+ -
7	<< >>
8	< <= > >=
9	== !=
10	&
11	^
12	`
13	&&	从左到右
14	`
15	?:	从右到左
16	= += -= *= /= %= &= ^= `	= <<= >>=`
17	,	从左到右

### 选择题
1. 以下哪个运算符是按位与运算符？
A. `|`
B. `&`
C. `^`
D. `~`

2. 若 `a = 5`（二进制 0101），`b = 3`（二进制 0011），那么 `a | b` 的结果是？
A. 2
B. 3
C. 6
D. 7

3. 对一个整数进行按位取反操作后，以下哪种说法是正确的？
A. 结果一定是正数
B. 结果一定是负数
C. 结果的绝对值与原数相同
D. 以上说法都不对

4. 左移运算符 `<<` 的作用是？
A. 将操作数的二进制位向右移动指定的位数
B. 将操作数的二进制位向左移动指定的位数，右边空出的位用 1 填充
C. 将操作数的二进制位向左移动指定的位数，右边空出的位用 0 填充
D. 对操作数的每一个二进制位取反

5. 若 `x = 10`（二进制 1010），`x >> 2` 的结果是？
A. 1
B. 2
C. 3
D. 4

6. 按位异或运算符 `^` 的特点是？
A. 相同为 1，不同为 0
B. 相同为 0，不同为 1
C. 只要有一个为 1 就为 1
D. 只有两个都为 1 才为 1

7. 以下哪个表达式等价于将整数 `num` 乘以 4 ？
A. `num << 2`
B. `num >> 2`
C. `num & 4`
D. `num | 4`

8. 若 `m = 15`（二进制 1111），`n = 7`（二进制 0111），`m & n` 的结果用十进制表示是？
A. 7
B. 8
C. 15
D. 16

### 判断题
1. 按位或运算符 `|` 是只要两个对应位中有一个为 1，结果位就为 1。（  ）
2. 左移运算符 `<<` 会将操作数的二进制位向左移动，左边空出的位用 0 填充。（  ）
3. 对一个正数进行按位取反操作后，结果一定是负数。（  ）
4. 按位异或运算符 `^` 可以用于交换两个变量的值而不使用额外的变量。（  ）
5. 右移运算符 `>>` 对于有符号数和无符号数的处理方式是一样的。（  ）
6. 若 `a = 3`（二进制 0011），`b = 5`（二进制 0101），`a ^ b` 的结果是 6。（  ）
7. 按位与运算符 `&` 可以用于判断一个整数是否为偶数，若 `num & 1` 结果为 0，则 `num` 是偶数。（  ）
8. 位运算符的优先级都高于算术运算符。（  ）

在C++里，位运算符有各自的优先级，这决定了在表达式里运算符执行的先后顺序。下面是常见位运算符以及它们和其他运算符的优先级顺序（从高到低）：

1. 按位取反（~）

这是单目运算符，优先级较高。它会对操作数的每一个二进制位取反。

2. 移位运算符（<< 和 >>）

优先级处于中间位置。<< 是左移运算符，会把操作数的二进制位向左移动指定的位数；>> 是右移运算符，会把操作数的二进制位向右移动指定的位数。

3. 按位与（&）

优先级低于移位运算符。它会对两个操作数的对应二进制位进行比较，只有当两个对应位都为 1 时，结果位才为 1。

4. 按位异或（^）

优先级低于按位与运算符。它会对两个操作数的对应二进制位进行比较，若两个对应位不同，结果位为 1，若相同则结果位为 0。

5. 按位或（|）

优先级最低。它会对两个操作数的对应二进制位进行比较，只要两个对应位中有一个为 1，结果位就为 1。

下面是包含不同位运算符的代码示例，用于展示优先级顺序：

#include <iostream>

int main() {
    int a = 5;  // 二进制: 0101
    int b = 3;  // 二进制: 0011
    int c = 2;  // 二进制: 0010

    // 表达式：~a << b & c ^ a | b
    // 1. 先计算按位取反：~a
    int notResult = ~a; 
    // 2. 接着计算移位：notResult << b
    int shiftResult = notResult << b; 
    // 3. 再计算按位与：shiftResult & c
    int andResult = shiftResult & c; 
    // 4. 然后计算按位异或：andResult ^ a
    int xorResult = andResult ^ a; 
    // 5. 最后计算按位或：xorResult | b
    int finalResult = xorResult | b; 

    std::cout << "表达式结果: " << finalResult << std::endl;

    return 0;
}

在实际编程时，为了让代码更具可读性，避免因优先级问题引发错误，建议使用括号来明确运算顺序。例如：

int result = ((~a) << b) & (c ^ a) | b;

这样就能清晰地表明每个运算符的运算顺序。

在C++中，左移运算符（<<）和右移运算符（>>）是用于对整数类型操作数进行二进制位移动的位运算符。下面详细介绍它们的作用和常见应用场景。

左移运算符（<<）

左移运算符会将操作数的二进制位向左移动指定的位数，右边空出的位用 0 填充。左移 n 位相当于将操作数乘以 2 的 n 次方。

作用

• 乘法运算替代：左移操作可以高效地实现乘以 2 的幂次的运算。相比于使用乘法运算符，左移运算在计算机底层执行速度更快，因为它只涉及到二进制位的移动操作。
• 位掩码操作：可以用于创建特定的位掩码，用于设置或提取特定的二进制位。

示例代码

#include <iostream>
int main() {
    int num = 5; // 二进制表示: 0101
    int shift = 2;
    int result = num << shift; 
    // 计算过程: 0101 左移 2 位后为 010100，十进制为 20
    std::cout << num << " 左移 " << shift << " 位的结果是: " << result << std::endl; 
    return 0;
}

右移运算符（>>）

右移运算符会将操作数的二进制位向右移动指定的位数，左边空出的位依据操作数的类型填充（有符号数填充符号位，无符号数填充 0）。右移 n 位相当于将操作数除以 2 的 n 次方（向下取整）。

作用

• 除法运算替代：右移操作可以高效地实现除以 2 的幂次的运算。与乘法类似，右移运算在计算机底层执行速度更快。
• 提取特定位：可以用于提取整数中的某些二进制位。

示例代码

#include <iostream>
int main() {
    int num = 5; // 二进制表示: 0101
    int shift = 1;
    int result = num >> shift; 
    // 计算过程: 0101 右移 1 位后为 0010，十进制为 2
    std::cout << num << " 右移 " << shift << " 位的结果是: " << result << std::endl; 
    return 0;
}

注意事项

• 数据溢出：左移操作可能会导致数据溢出，因为左移后可能会丢失最高位的信息。
• 符号位处理：对于有符号数的右移操作，左边空出的位会填充符号位，这可能会影响最终的结果。

综上所述，左移和右移运算符在性能优化和位操作方面具有重要作用，可以在一些场景中替代乘法和除法运算，提高程序的执行效率。

#include<iostream>
using namespace std;
int main() {
/*
	~非位运算 
	&按位与
	|按位或
	^按位异或
*/
	cout<<(5&2)<<endl;
	cout<<(7&5)<<endl;
	return 0;
}

以下为你详细介绍C++位运算符及其计算过程。

按位与（&）

按位与操作会对两个操作数的对应二进制位进行比较，只有当两个对应位都为 1 时，结果位才为 1，否则为 0。

#include <iostream>
int main() {
    int num1 = 5; // 二进制: 0101
    int num2 = 3; // 二进制: 0011
    int result = num1 & num2; 
    // 计算过程：
    //  0101
    //& 0011
    // ----
    //  0001
    std::cout << "按位与结果: " << result << std::endl; 
    return 0;
}

在上述代码中，num1 和 num2 按位与后，结果为二进制的 0001，也就是十进制的 1。

按位或（|）

按位或操作会对两个操作数的对应二进制位进行比较，只要两个对应位中有一个为 1，结果位就为 1，只有当两个对应位都为 0 时，结果位才为 0。

#include <iostream>
int main() {
    int num1 = 5; // 二进制: 0101
    int num2 = 3; // 二进制: 0011
    int result = num1 | num2; 
    // 计算过程：
    //  0101
    //| 0011
    // ----
    //  0111
    std::cout << "按位或结果: " << result << std::endl; 
    return 0;
}

这里，num1 和 num2 按位或后，结果是二进制的 0111，即十进制的 7。

按位异或（^）

按位异或操作会对两个操作数的对应二进制位进行比较，若两个对应位不同，结果位为 1，若相同则结果位为 0。

#include <iostream>
int main() {
    int num1 = 5; // 二进制: 0101
    int num2 = 3; // 二进制: 0011
    int result = num1 ^ num2; 
    // 计算过程：
    //  0101
    //^ 0011
    // ----
    //  0110
    std::cout << "按位异或结果: " << result << std::endl; 
    return 0;
}

此例中，num1 和 num2 按位异或后，结果是二进制的 0110，也就是十进制的 6。

按位取反（~）

按位取反操作会对操作数的每一个二进制位取反，将 1 变为 0，将 0 变为 1。

#include <iostream>
int main() {
    int num = 5; // 二进制: 0000 0000 0000 0000 0000 0000 0101
    int result = ~num; 
    // 计算过程：
    // 原码：0000 0000 0000 0000 0000 0000 0101
    // 取反：1111 1111 1111 1111 1111 1111 1010（补码表示的 -6）
    std::cout << "按位取反结果: " << result << std::endl; 
    return 0;
}

对于 num 按位取反，要注意在计算机中负数通常以补码形式存储。这里取反后的结果在补码表示下是 -6。

左移（<<）

左移操作会将操作数的二进制位向左移动指定的位数，右边空出的位用 0 填充。

#include <iostream>
int main() {
    int num = 5; // 二进制: 0101
    int shift = 2;
    int result = num << shift; 
    // 计算过程：
    // 原二进制: 0101
    // 左移 2 位: 010100
    std::cout << "左移 " << shift << " 位结果: " << result << std::endl; 
    return 0;
}

num 左移 2 位后，结果是二进制的 010100，也就是十进制的 20。

右移（>>）

右移操作会将操作数的二进制位向右移动指定的位数，左边空出的位依据操作数的类型填充（有符号数填充符号位，无符号数填充 0）。

#include <iostream>
int main() {
    int num = 5; // 二进制: 0101
    int shift = 1;
    int result = num >> shift; 
    // 计算过程：
    // 原二进制: 0101
    // 右移 1 位: 0010
    std::cout << "右移 " << shift << " 位结果: " << result << std::endl; 
    return 0;
}

num 右移 1 位后，结果是二进制的 0010，即十进制的 2。

这些例子能帮助你理解 C++ 位运算符的计算过程。在实际编程里，位运算可以高效处理特定问题，像标志位的设置与检查、数据压缩等。

#include<iostream>
using namespace std;
int main() {
/*
	~非位运算 
	&按位与
	|按位或
	^按位异或
*/
	int n;
	cin >> n;
	
	return 0;
}