Golang中的位操作技巧与实践

有趣。最高有效位是什么？

func main() {
    fmt.Println("hello world")
}

让我看看我是否正确理解了你的意思。

“二进制补码”基本上意味着对每一位取反然后加 1。

0 -> 000 -> 111

我在这里停一下。所以在 000 中，你对每个 0 取反并加 1，因此得到 111？

我不理解第四列。

我想我理解了 1 的前三列。

我不理解 2 的第三列。不应该是 011 吗？

-4 -> 100 -> 011 -> 100 // 警告！4 在 3 位有符号表示中是不可表示的！

为什么会这样？

我不理解 -2 和 -2 的第三列。

很抱歉我的知识如此欠缺。这背后有原因。感谢你的耐心。

cherilexvold1974:

我很想了解更多关于“最小可表示值”和“最大可表示值”的信息。

具体是指什么？

核心在于，如果你拥有的数字位数是有限的，那么你能表示的值也是有限的。这就像你的汽车里程表一样。你有6位数字来表示里程，从0开始，最大值将是999999。之后，它会重新归零。二进制数也是类似的。唯一的例外是，我们只有0和1作为数字，而不是0到9。

另一件事是，我们没有 - 号来表示一个值的负性。但一些工程师们约定，在有符号整数类型中，将最高有效位作为“负号”。他们还约定使用二进制补码，而不是简单地反转每一位，因为使用二进制补码可以直接进行正负数的加法运算：

让我们用3位有符号整数计算 `-2 + 3`

十进制    二进制补码    普通反转
 -2       110           101
+ 3       011           011
===       ===           ===
  1     (1)001        (1)000

如你所见，在二进制补码表示法中，我们自然地得到了 1 的二进制表示，而在普通反转法中，我们需要跟踪我们越过了 0 的边界这一事实，并且必须手动再加一个 1 来修正结果。

位操作核心概念解析

1. 基础类型与表示

var x uint8 = 0xAC  // uint8是无符号8位整数，范围0-255
// 0xAC是十六进制表示：
// A = 10(十进制) = 1010(二进制)
// C = 12(十进制) = 1100(二进制)
// 0xAC = 10101100(二进制) = 172(十进制)

2. 位运算符详解

// & 是按位AND运算符
x &= 0xF0  // 等价于 x = x & 0xF0
// 0xF0 = 11110000(二进制) = 240(十进制)

// 计算过程：
//   10101100 (x = 0xAC)
// & 11110000 (0xF0)
//   ---------
//   10100000 = 0xA0 = 160(十进制)

3. 完整示例演示

package main

import "fmt"

func main() {
    var x uint8 = 0xAC  // 10101100
    
    fmt.Printf("原始值: %08b = 0x%X = %d\n", x, x, x)
    
    // AND操作
    x &= 0xF0
    fmt.Printf("AND 0xF0后: %08b = 0x%X = %d\n", x, x, x)
    
    // OR操作示例
    var y uint8 = 0x0A  // 00001010
    y |= 0xF0           // OR操作
    fmt.Printf("OR 0xF0后: %08b = 0x%X = %d\n", y, y, y)
    
    // XOR操作示例
    var z uint8 = 0xAA  // 10101010
    z ^= 0xFF           // XOR操作
    fmt.Printf("XOR 0xFF后: %08b = 0x%X = %d\n", z, z, z)
}

4. 常用位操作技巧

// 1. 检查特定位是否设置
func isBitSet(num, pos uint8) bool {
    return (num & (1 << pos)) != 0
}

// 2. 设置特定位
func setBit(num, pos uint8) uint8 {
    return num | (1 << pos)
}

// 3. 清除特定位
func clearBit(num, pos uint8) uint8 {
    return num & ^(1 << pos)
}

// 4. 切换特定位
func toggleBit(num, pos uint8) uint8 {
    return num ^ (1 << pos)
}

// 5. 提取低位字节
func getLowByte(value uint16) uint8 {
    return uint8(value & 0xFF)
}

// 6. 判断奇偶（最低位检查）
func isEven(num uint8) bool {
    return num&1 == 0
}

5. 实际应用场景

// 标志位管理
const (
    FlagRead    = 1 << iota  // 00000001
    FlagWrite                // 00000010  
    FlagExecute              // 00000100
)

func main() {
    var permissions uint8 = 0
    
    // 设置权限
    permissions |= FlagRead | FlagWrite  // 00000011
    
    // 检查权限
    canRead := permissions&FlagRead != 0  // true
    canExecute := permissions&FlagExecute != 0  // false
    
    // 移除权限
    permissions &^= FlagWrite  // 清除写权限
    
    fmt.Printf("权限位: %08b\n", permissions)
}

6. MSB（最高有效位）操作

// 获取MSB（第7位，从0开始计数）
func getMSB(num uint8) uint8 {
    return (num >> 7) & 1
}

// 检查是否为负数（对于有符号数）
func isNegative(num int8) bool {
    return num&0x80 != 0  // 检查符号位
}

7. 性能优化示例

// 使用位操作实现快速乘除
func multiplyByPowerOfTwo(num, power uint) uint {
    return num << power  // 相当于 num * 2^power
}

func divideByPowerOfTwo(num, power uint) uint {
    return num >> power  // 相当于 num / 2^power
}

// 交换两个变量（不使用临时变量）
func swap(a, b *int) {
    *a ^= *b
    *b ^= *a
    *a ^= *b
}

Go中的位操作直接对应CPU指令，执行效率高。&对应AND，|对应OR，^对应XOR，&^对应AND NOT。这些操作在底层编程、协议解析、性能优化等场景中非常实用。