【拒绝算法PUA】0x00-位运算

“位运算”基本概念和使用场景

位(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;
    }
};

参考资料

1. https://learn.microsoft.com/zh-cn/cpp/cpp/bitwise-exclusive-or-operator-hat?view=msvc-170

2. https://leetcode.cn/problems/utf-8-validation/description/