Go语言中的位字段与位打包实践

#pragma pack(push,1)
struct my_chunk{
    unsigned short fieldA: 16; // 占用16位
    unsigned short fieldB: 15; // 占用15位
    unsigned short fieldC:  1; // 占用1位
};
#pragma pop()

// 访问示例
struct my_chunk aChunk;
aChunk.fieldA = 3;
aChunk.fieldB = 2;
aChunk.fieldC = 1;

package main

import (
    "fmt"
)

// MyChunk 结构体用于模拟位字段，内部使用一个uint32来存储所有位
type MyChunk struct {
    data uint32
}

// 定义每个字段的位偏移和位掩码
// fieldA: 0-15位 (16位)
const (
    fieldAOffset = 0
    fieldAMask   = 0xFFFF // 16个1，即2^16 - 1
)

// fieldB: 16-30位 (15位)
const (
    fieldBOffset = 16
    fieldBMask   = 0x7FFF // 15个1，即2^15 - 1
)

// fieldC: 31位 (1位)
const (
    fieldCOffset = 31
    fieldCMask   = 0x1 // 1个1
)

// NewMyChunk 创建并初始化一个MyChunk实例
func NewMyChunk() *MyChunk {
    return &MyChunk{}
}

// SetFieldA 设置 fieldA 的值
func (m *MyChunk) SetFieldA(val uint16) {
    // 1. 清除fieldA所在区域的旧值：使用按位非操作符和fieldAMask的左移版本来创建一个清除掩码
    //    ^(fieldAMask << fieldAOffset) 会在fieldA区域生成0，其他区域生成1
    m.data = (m.data & ^(uint32(fieldAMask) << fieldAOffset)) | // 清除旧值
        ((uint32(val) & fieldAMask) << fieldAOffset) // 写入新值，并确保新值不超过fieldA的位宽
}

// GetFieldA 获取 fieldA 的值
func (m *MyChunk) GetFieldA() uint16 {
    // 1. 将fieldA右移到最低位
    // 2. 使用fieldAMask清除高位，只保留fieldA的值
    return uint16((m.data >> fieldAOffset) & uint32(fieldAMask))
}

// SetFieldB 设置 fieldB 的值
func (m *MyChunk) SetFieldB(val uint16) {
    m.data = (m.data & ^(uint32(fieldBMask) << fieldBOffset)) |
        ((uint32(val) & fieldBMask) << fieldBOffset)
}

// GetFieldB 获取 fieldB 的值
func (m *MyChunk) GetFieldB() uint16 {
    return uint16((m.data >> fieldBOffset) & uint32(fieldBMask))
}

// SetFieldC 设置 fieldC 的值
func (m *MyChunk) SetFieldC(val bool) { // fieldC是1位，通常表示布尔值
    bitVal := uint32(0)
    if val {
        bitVal = 1
    }
    m.data = (m.data & ^(uint32(fieldCMask) << fieldCOffset)) |
        ((bitVal & fieldCMask) << fieldCOffset)
}

// GetFieldC 获取 fieldC 的值
func (m *MyChunk) GetFieldC() bool {
    return ((m.data >> fieldCOffset) & uint32(fieldCMask)) == 1
}

func main() {
    chunk := NewMyChunk()

    // 设置值
    chunk.SetFieldA(12345) // 16位最大值是65535
    chunk.SetFieldB(30000) // 15位最大值是32767
    chunk.SetFieldC(true)

    fmt.Printf("原始数据 (uint32): %032b (二进制)\n", chunk.data)
    fmt.Printf("原始数据 (十进制): %d\n", chunk.data)

    // 获取值
    fieldAVal := chunk.GetFieldA()
    fieldBVal := chunk.GetFieldB()
    fieldCVal := chunk.GetFieldC()

    fmt.Printf("FieldA: %d\n", fieldAVal)
    fmt.Printf("FieldB: %d\n", fieldBVal)
    fmt.Printf("FieldC: %t\n", fieldCVal)

    // 尝试设置一个超出位宽的值
    fmt.Println("\n尝试设置超出位宽的值:")
    chunk.SetFieldB(40000) // 40000 > 32767 (15位最大值)
    fmt.Printf("原始数据 (uint32): %032b (二进制)\n", chunk.data)
    fmt.Printf("FieldB (截断后): %d\n", chunk.GetFieldB()) // 应该被截断

    // 验证值是否正确
    expectedB := uint16(40000) & fieldBMask // 预期被截断的值
    fmt.Printf("预期FieldB (截断后): %d\n", expectedB)
}