文章目录
“位运算”基本概念和使用场景
位(bit)
计算机普遍使用二进制来存储、处理数据。在二进制表示法中,“位(bit)”是最小单位。一个“位”有两种取值:0
和1
。八个“位”组成一个字节(byte
)
正数表示法
当用于表示非负整数时,通常直接将十进制数字转换成二进制,就能得到计算机的位表示。
3 | 2 | 1 | 0 |
---|---|---|---|
1 | 0 | 1 | 1 |
比如“1011”对应的数值是1 * 2^3
+ 0 * 2^2
+ 1 * 2^1
+ 1 * 1^0
= 11
。
负数表示法
当用于表示负数时,当今大多数的计算机采用补码表示法。
在这种表示法中,最高的位为1
表示其为一个负数,该数值的绝对值等于所有位取反再加1
。
高位7 | 6 | 5 | 4 | 3 | 2 | 1 | 低位0 |
---|---|---|---|---|---|---|---|
1 | 1 | 1 | 1 | 0 | 1 | 0 | 1 |
比如:11110101
中最高位的1
说明它是负数;
高位7 | 6 | 5 | 4 | 3 | 2 | 1 | 低位0 |
---|---|---|---|---|---|---|---|
0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 |
对其取反之后得到00001010
;
此时,在低位0
再加1
高位7 | 6 | 5 | 4 | 3 | 2 | 1 | 低位0 |
---|---|---|---|---|---|---|---|
0 | 0 | 0 | 0 | 1 | 0 | 1 | 1 |
再加1
变成00001011
表示整数11
,因此11110101
表示的值是-11
。
位操作(bitwise operations)
取反 ( ~
)
按位取反运算符(~)是指将整数的各个二进制位都取反。使数字1
成为0
,0
成为1
。
例如1:十进制7
按位取反
3 | 2 | 1 | 0 |
---|---|---|---|
0 | 1 | 1 | 1 |
取反结果:
3 | 2 | 1 | 0 |
---|---|---|---|
1 | 0 | 0 | 0 |
例如2:
~9
=-10
因为9
(00001001
)所有位取反即为(11110110
),这个数最高位是1
,所以是补码。
补码还原成反码(反码等于补码减1
)得到(11110101
),再还原为原码(反码到原码最高位不变,其它各位取反)等于(10001010
),十进制为-10
。
- 代码
unsigned short a = 9; // 补码 00001001
int b = ~a;
cout << b << endl; // prints -10
按位与 ( &
)
按位“与”运算符的两个操作数必须为整型类型。
按位与处理两个长度相同的二进制数,两个相应的二进位当且仅当二者都为1
,该位的结果值才为1
,否则为0
。
例如:
3 | 2 | 1 | 0 |
---|---|---|---|
0 | 1 | 0 | 1 |
& | & | & | & |
0 | 0 | 1 | 1 |
= | = | = | = |
0 | 0 | 0 | 1 |
0101
和0011
按位与得到0001
- 代码例子
按位“与”运算符:&
// expre_Bitwise_AND_Operator.cpp
// compile with: /EHsc
// Demonstrate bitwise AND
#include <iostream>
using namespace std;
int main() {
unsigned short a = 0xCCCC; // pattern 1100 ...
unsigned short b = 0xAAAA; // pattern 1010 ...
cout << hex << ( a & b ) << endl; // prints "8888", pattern 1000 ...
}
按位或 ( |
)
-
按位或处理两个长度相同的二进制数,该运算符的两个操作数必须为整型类型。
-
按位“
与或
”运算符 (|
) 将其第一操作数的每个位与第二操作数的相应位进行比较。 两个相应的二进位中只要有一个为1
,该位的结果值为1
。 否则,将对应的结果位设置为0
。
3 | 2 | 1 | 0 |
---|---|---|---|
0 | 1 | 0 | 1 |
| | | | | | | |
0 | 0 | 1 | 1 |
= | = | = | = |
0 | 1 | 1 | 1 |
例如:
0101
和0011
按位或得到0111
- 代码例子
按位与或运算符:|
// expre_Bitwise_Inclusive_OR_Operator.cpp
// compile with: /EHsc
// Demonstrate bitwise inclusive OR
#include <iostream>
using namespace std;
int main() {
unsigned short a = 0x5555; // pattern 0101 ...
unsigned short b = 0xAAAA; // pattern 1010 ...
cout << hex << ( a | b ) << endl; // prints "ffff" pattern 1111 ...
}
按位异或 ( ^
)
按位异或运算,对等长二进制模式或二进制数的每一位执行逻辑异或操作。操作的结果是如果某位不同则该位为1
,否则该位为0
。
3 | 2 | 1 | 0 |
---|---|---|---|
0 | 1 | 0 | 1 |
^ | ^ | ^ | ^ |
0 | 0 | 1 | 1 |
= | = | = | = |
0 | 1 | 1 | 0 |
例如:
0101
和0011
按位异或得到0110
- 代码例子
按位异或运算符:^
// expre_Bitwise_Exclusive_OR_Operator.cpp
// compile with: /EHsc
// Demonstrate bitwise exclusive OR
#include <iostream>
using namespace std;
int main() {
unsigned short a = 0x5555; // pattern 0101 ...
unsigned short b = 0xFFFF; // pattern 1111 ...
cout << hex << ( a ^ b ) << endl; // prints "aaaa" pattern 1010 ...
}
逻辑左移
逻辑左移把所有的位向左边移动指定的个数,在右边填充0
。例如下面的图解释了左移1
位的过程:
逻辑右移
逻辑右移把所有的位向右边移动指定的个数,在左边填充0
。例如下面的图解释了右移1
位的过程:
算数移位
-
算术移位分为左移和右移。算术左移与逻辑左移完全一样,此处不再赘述。
-
算术右移只在对负数移位时与逻辑右移不同:当对负数移位时,算术右移在左边补1而不是
0
。
例如:
常见陷阱
位运算结果可能为负数
通常需要位运算的场景,如硬件操作、协议报文等,都很少会出现负数。位运算的结果一般需要解释为非负整数。对于这种场景,需要注意避免使用有符号数。
对于默认数据类型有符号的语言(Java
, Python
),应当避免翻转数字的最高位(即符号位); 如果避免不了,那么应当保证移位的结果不会用于其他依赖于正负符号的数学运算,如大小比较等。
x
是有符号的8
位整型数字,当向左移了6
位后,x
变成“11000000
”,由于符号位为1
,该数值为-64
。
int8_t x = 0b00001011;
x = x << 6;
if (x < 0) {
cout << "Negtive.";
}
位操作数为负数
当操作数为负数时,其最高位(符号位)为
1
。进行位运算时,最高位可能被改变,导致其正负号被改变,数值与预期不符。
如果确实要对负数进行右移操作,需要注意特定编程语言中是算术右移还是逻辑右移,两者结果不同。
有些语言规定算术右移和逻辑右移的运算符不同,比如:Java
中算术右移">>"
, 逻辑右移">>>"
;在大多数编程语言中(包括C++
),对于有符号整数类型,使用 ">>"
操作符通常执行算术右移。
因此,对于无符号整数类型或明确希望执行逻辑右移的情况,应确保使用适当的无符号类型或进行类型转换。
逻辑右移和算术右移的区别
逻辑右移和算术右移是位运算中的两种右移操作,它们之间的主要区别在于处理符号位(最高位)的方式不同。
-
逻辑右移(
Logical Shift Right
):
逻辑右移用于无符号整数。在逻辑右移中,位向右移动指定的位数,左侧用0
填充,不考虑符号位。换句话说,逻辑右移总是将最高位设置为0
,其余位则向右移动。这种移位操作适用于无符号数或逻辑运算,其中符号位没有特殊含义。例如: 对于无符号整数
0010 1100
(二进制表示,对应十进制数44
),逻辑右移2位后得到0000 1011
(对应十进制数11
)。二进制 十进制数 0010 1100 44 执行逻辑右移两位:
二进制 十进制数 0000 1011 11 unsigned int num = 44; // 二进制表示为 0010 1100 int shiftAmount = 2; // 要右移的位数 unsigned int result = num >> shiftAmount; // result = 0000 1011 std::cout << "原始数值(二进制): " << std::bitset<8>(num) << std::endl; std::cout << "右移后的数值(二进制): " << std::bitset<8>(result) << std::endl;
打印结果:
原始数值(二进制):00101100
右移后的数值(二进制):00001011
-
算术右移(
Arithmetic Shift Right
):
算术右移用于有符号整数。在算术右移中,位向右移动指定的位数,但左侧用符号位填充。如果符号位为0
,则左侧填充0
;如果符号位为1
,则左侧填充1
。这种移位操作保持了数值的符号不变,并适用于有符号数的除法运算(除以2
的幂)。例如:对于有符号整数
1101 1000
(二进制表示,对应十进制数-40
,采用二进制补码表示),算术右移2
位后得到1111 1101
(对应十进制数-10
)。二进制 十进制数 1101 1000 -40 执行算术右移两位:
二进制 十进制数 1111 1101 -10
总结: 逻辑右移和算术右移的主要区别在于处理符号位的方式:逻辑右移总是用0填充左侧空位,而算术右移则用符号位填充左侧空位以保持数值的符号不变。
OJ练习
Leetcode: 393.UTF-8 编码验证
给定一个表示数据的整数数组 data
,返回它是否为有效的 UTF-8
编码。
UTF-8
中的一个字符可能的长度为 1
到 4
字节,遵循以下的规则:
- 对于
1
字节 的字符,字节的第一位设为0
,后面7
位为这个符号的unicode
码。 对于n
字节 的字符 - (
n > 1
),第一个字节的前n
位都设为1
,第n+1
位设为0
,后面字节的前两位一律设为10
。 - 剩下的没有提及的二进制位,全部为这个符号的
unicode
码。
这是 UTF-8
编码的工作方式:
Number of Bytes | UTF-8 octet sequence
| (binary)
--------------------+---------------------------------------------
1 | 0xxxxxxx
2 | 110xxxxx 10xxxxxx
3 | 1110xxxx 10xxxxxx 10xxxxxx
4 | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
x
表示二进制形式的一位,可以是 0
或 1
。
注意:输入是整数数组。只有每个整数的 最低8
个有效位 用来存储数据。这意味着每个整数只表示 1
字节的数据。
分析
UTF-8
是一种可变长度的Unicode
字符编码,一个字符可能占用1
到4
个字节。每个字节由一个整数表示(通常,一个字节是一个0
到255
的整数)。
1、计算字符使用UTF-8
编码是占用几字节(1
到4
个)
- 计算一个字节对应的
UTF-8
字符应该占用多少个字节。 - 它首先检查字节的最高位(即
UTF-8
的多字节序列的起始字节)。 - 如果最高位为
0
,则这是一个单字节字符,返回1
。 - 否则,计算连续多少个最高位是
1
,1
的数量决定了字符应该占用多少个字节。 - 如果字节数超过
4
(UTF-8
的最大长度),则表示这不是一个有效的UTF-8
编码。 - 如果字节数是
2
或更多,则返回字节数;否则表示这不是一个有效的UTF-8
编码。
2、检查后续的每个字节是否都是有效的UTF-8
续行字节。
代码
class Solution {
public:
static const int MASK1 = 1 << 7; // 1 << 7 == 1000 0000
// 1 << 6 == 0100 0000
// (1 << 7) + (1 << 6) == 1100 0000
static const int MASK2 = (1 << 7) + (1 << 6);
/**
* 判断首字节之后的字节,如果满足UTF-8编码,返回true;否则返回false
* */
bool isValid(int num) {
// num && MASK2 获取前最高位两个比特位数据
// (num & MASK2) == MASK1 判断最高两位是否是10,其实就是与MASK1是否相等
return (num & MASK2) == MASK1;
}
/**
* 根据首字节获取该字符由UTF-8编码时应该是多少字节
*
* @param num 首字节整数
* @retval 字节数量
* */
int getBytes(int num) {
if ((num & MASK1) == 0) { // 判断头字节和 MASK1的按位与运算结果是否为0
return 1;
}
int n = 0;
int mask = MASK1;
while ((num & mask) != 0) { // num & mask得到当前比特位是0还是1
n++;
if (n > 4) { //如果大于4说明,不是UTF-8有效
return -1;
}
mask >>= 1; // 掩码右移1位,当num & mask的时,就得到的是下一个比特位是0还是1
}
return n >= 2 ? n : -1;
}
bool validUtf8(vector<int> &data) {
int m = data.size();
int index = 0;
while (index < m) {
int num = data[index];
int n = getBytes(num);
if (n < 0 || index + n > m) {
return false;
}
// 从第二个字节开始判断,最高两位是否是10
for (int i = 1; i < n; i++) {
if (!isValid(data[index + i])) { // 检查一个字节是否是有效的UTF-8编码的
return false;
}
}
index += n;
}
return true;
}
};
参考资料
-
https://learn.microsoft.com/zh-cn/cpp/cpp/bitwise-exclusive-or-operator-hat?view=msvc-170
-
https://leetcode.cn/problems/utf-8-validation/description/