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"

// MyPackedData 结构体用于存储打包后的位数据
type MyPackedData struct {
    Value uint32 // 使用 uint32 存储 32 位数据
}

// 定义各个字段的掩码和位移量
// FieldA: 16 位，从第 0 位开始 (0-15)
const (
    fieldAMask  uint32 = 0xFFFF       // 16个1，用于掩码
    fieldAShift uint   = 0            // 字段A的起始位移
)

// FieldB: 15 位，从第 16 位开始 (16-30)
const (
    fieldBMask  uint32 = 0x7FFF       // 15个1，用于掩码
    fieldBShift uint   = 16           // 字段B的起始位移
)

// FieldC: 1 位，从第 31 位开始 (31)
const (
    fieldCMask  uint32 = 0x1          // 1个1，用于掩码
    fieldCShift uint   = 31           // 字段C的起始位移
)

// GetFieldA 获取 FieldA 的值 (16 位)
func (mpd *MyPackedData) GetFieldA() uint16 {
    // 1. 将数据右移到最低位
    // 2. 使用掩码只保留字段A的位
    return uint16((mpd.Value >> fieldAShift) & fieldAMask)
}

// SetFieldA 设置 FieldA 的值 (16 位)
func (mpd *MyPackedData) SetFieldA(val uint16) {
    // 1. 清除当前 FieldA 区域的位：
    //    (fieldAMask << fieldAShift) 生成 FieldA 区域的掩码
    //    ^ (异或) 用于反转掩码，然后 & (与) 操作将 FieldA 区域置零
    mpd.Value = mpd.Value &^ (fieldAMask << fieldAShift)
    // 2. 将新值左移到 FieldA 区域，然后 | (或) 操作将其设置到 Value 中
    mpd.Value = mpd.Value | (uint32(val) << fieldAShift)
}

// GetFieldB 获取 FieldB 的值 (15 位)
func (mpd *MyPackedData) GetFieldB() uint16 {
    return uint16((mpd.Value >> fieldBShift) & fieldBMask)
}

// SetFieldB 设置 FieldB 的值 (15 位)
func (mpd *MyPackedData) SetFieldB(val uint16) {
    // 确保输入值不会超出字段的位宽，防止溢出到其他字段
    val &= uint16(fieldBMask)
    mpd.Value = (mpd.Value &^ (fieldBMask << fieldBShift)) | (uint32(val) << fieldBShift)
}

// GetFieldC 获取 FieldC 的值 (1 位，作为布尔值)
func (mpd *MyPackedData) GetFieldC() bool {
    return ((mpd.Value >> fieldCShift) & fieldCMask) != 0
}

// SetFieldC 设置 FieldC 的值 (1 位，作为布尔值)
func (mpd *MyPackedData) SetFieldC(val bool) {
    if val {
        // 设置位：将掩码左移到正确位置，然后进行或操作
        mpd.Value = mpd.Value | (fieldCMask << fieldCShift)
    } else {
        // 清除位：将掩码左移到正确位置，然后进行与非操作
        mpd.Value = mpd.Value &^ (fieldCMask << fieldCShift)
    }
}

func main() {
    var data MyPackedData

    fmt.Printf("初始值: 0x%08X\n", data.Value) // 0x00000000

    // 设置 FieldA
    data.SetFieldA(12345)
    fmt.Printf("设置 FieldA(12345) 后: 0x%08X, FieldA: %d\n", data.Value, data.GetFieldA())
    // 预期: 0x00003039 (12345 = 0x3039)

    // 设置 FieldB
    data.SetFieldB(1023) // 1023 = 0x3FF
    fmt.Printf("设置 FieldB(1023) 后: 0x%08X, FieldB: %d\n", data.Value, data.GetFieldB())
    // 预期: FieldB 在第16位开始，所以 0x3FF << 16 = 0x03FF0000
    // 0x00003039 | 0x03FF0000 = 0x03FF3039

    // 设置 FieldC
    data.SetFieldC(true)
    fmt.Printf("设置 FieldC(true) 后: 0x%08X, FieldC: %t\n", data.Value, data.GetFieldC())
    // 预期: FieldC 在第31位，所以 0x1 << 31 = 0x80000000
    // 0x03FF3039 | 0x80000000 = 0x83FF3039

    // 再次获取所有字段的值
    fmt.Println("\n再次获取所有字段:")
    fmt.Printf("FieldA: %d\n", data.GetFieldA()) // 12345
    fmt.Printf("FieldB: %d\n", data.GetFieldB()) // 1023
    fmt.Printf("FieldC: %t\n", data.GetFieldC()) // true

    // 尝试设置 FieldA 为一个超出16位的值
    data.SetFieldA(65536) // 65536 = 0x10000, 16位最大值是65535
    fmt.Printf("设置 FieldA(65536) 后: 0x%08X, FieldA: %d (应为0)\n", data.Value, data.GetFieldA())
    // 注意：我们的SetFieldA没有做溢出检查，超出部分会被截断。
    // 实际上，uint16(65536) 会变成 0，所以 FieldA 设为 0。
    // 如果需要严格的溢出检查，可以在Set方法内部添加逻辑。
    // 对于SetFieldA，由于输入是uint16，它本身就限制了16位，所以不需要额外的掩码。
    // 但对于SetFieldB，我们添加了 `val &= uint16(fieldBMask)` 来确保值在15位范围内。
}