Go语言中的位字段与位封装：实现与最佳实践

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

package main

import "fmt"

// MyChunk 类型模拟C语言中的位字段结构，底层使用一个uint32来存储所有数据
type MyChunk uint32

// 定义位字段的偏移量和掩码。
// 位字段从低位（LSB）向高位（MSB）依次排列，以确保与C示例的32位对齐。
const (
    // fieldA: 16位，占用0-15位
    fieldAOffset = 0
    fieldABits   = 16
    fieldAMask   = (1<<fieldABits - 1) << fieldAOffset // 生成16个1的掩码，并左移到正确位置

    // fieldB: 15位，占用16-30位
    fieldBOffset = 16
    fieldBBits   = 15
    fieldBMask   = (1<<fieldBBits - 1) << fieldBOffset // 生成15个1的掩码，并左移到正确位置

    // fieldC: 1位，占用31位
    fieldCOffset = 31
    fieldCBits   = 1
    fieldCMask   = (1<<fieldCBits - 1) << fieldCOffset // 生成1个1的掩码，并左移到正确位置
)

// GetFieldA 获取MyChunk中FieldA的值
func (mc MyChunk) GetFieldA() uint16 {
    // 1. 使用掩码提取FieldA所在的位
    // 2. 将结果右移到最低位
    // 3. 转换为FieldA的实际类型 (uint16)
    return uint16((mc & fieldAMask) >> fieldAOffset)
}

// SetFieldA 设置MyChunk中FieldA的值
func (mc *MyChunk) SetFieldA(val uint16) {
    // 1. 清除FieldA当前的值：通过对FieldA的掩码取反，然后与原始值进行位与操作
    // 2. 准备新值：将传入的val转换为MyChunk类型，然后左移到FieldA的正确位置，并与FieldA的掩码进行位与操作，确保不超过位宽
    // 3. 合并新值：将清除后的原始值与准备好的新值进行位或操作
    *mc = (*mc & ^fieldAMask) | ((MyChunk(val) << fieldAOffset) & fieldAMask)
}

// GetFieldB 获取MyChunk中FieldB的值
func (mc MyChunk) GetFieldB() uint16 {
    return uint16((mc & fieldBMask) >> fieldBOffset)
}

// SetFieldB 设置MyChunk中FieldB的值
func (mc *MyChunk) SetFieldB(val uint16) {
    *mc = (*mc & ^fieldBMask) | ((MyChunk(val) << fieldBOffset) & fieldBMask)
}

// GetFieldC 获取MyChunk中FieldC的值
func (mc MyChunk) GetFieldC() uint8 {
    return uint8((mc & fieldCMask) >> fieldCOffset)
}

// SetFieldC 设置MyChunk中FieldC的值
func (mc *MyChunk) SetFieldC(val uint8) {
    *mc = (*mc & ^fieldCMask) | ((MyChunk(val) << fieldCOffset) & fieldCMask)
}

func main() {
    var aChunk MyChunk // 初始化一个MyChunk实例，默认为0

    fmt.Printf("初始 MyChunk 值: 0x%08X\n", aChunk)

    // 设置并验证 FieldA
    aChunk.SetFieldA(3)
    fmt.Printf("设置 FieldA 为 3: 0x%08X, 获取 FieldA: %d\n", aChunk, aChunk.GetFieldA())

    // 设置并验证 FieldB
    aChunk.SetFieldB(2)
    fmt.Printf("设置 FieldB 为 2: 0x%08X, 获取 FieldB: %d\n", aChunk, aChunk.GetFieldB())

    // 设置并验证 FieldC
    aChunk.SetFieldC(1)
    fmt.Printf("设置 FieldC 为 1: 0x%08X, 获取 FieldC: %d\n", aChunk, aChunk.GetFieldC())

    // 最终验证所有字段
    fmt.Println("\n最终所有字段值:")
    fmt.Printf("FieldA: %d\n", aChunk.GetFieldA())
    fmt.Printf("FieldB: %d\n", aChunk.GetFieldB())
    fmt.Printf("FieldC: %d\n", aChunk.GetFieldC())

    // 另一个示例
    var anotherChunk MyChunk
    anotherChunk.SetFieldA(12345) // 16位最大值是65535
    anotherChunk.SetFieldB(32767) // 15位最大值是32767
    anotherChunk.SetFieldC(1)     // 1位最大值是1
    fmt.Printf("\n另一个 MyChunk 实例: 0x%08X\n", anotherChunk)
    fmt.Printf("获取 FieldA: %d\n", anotherChunk.GetFieldA())
    fmt.Printf("获取 FieldB: %d\n", anotherChunk.GetFieldB())
    fmt.Printf("获取 FieldC: %d\n", anotherChunk.GetFieldC())
}