Rust中如何将两个7位结构体存入单字节枚举？是否有子字节优化方案？

我有两个结构体，各自仅需7位就能完整表示：

#[repr(transparent)]
struct TypeFlags(u8);

// TypeFlags 拥有 Control 不具备的能力
impl std::ops::BitOr for TypeFlags {
    type Output = Self;

    fn bitor(self, rhs: Self) -> Self::Output {
        Self(self.0 | rhs.0)
    }
}

#[repr(transparent)]
struct Control(u8);

由于两者都仅需7位，理论上可以创建一个仅占用1字节的“Either”类型，但两种尝试都存在问题：

// 问题：编译器会为枚举变体分配一个“标志”字节，总大小为2字节
enum Either {
    Type(TypeFlags),
    Ctrl(Control)
}

// 问题：模式匹配非常繁琐
struct PackedEither(u8);

请问是否存在可利用的枚举子字节优化方案，还是必须像PackedEither这样手动实现位标志？

可以通过手动指定枚举判别式并配合合适的repr属性实现1字节的Either类型，利用剩余的1位作为变体区分标志，无需完全手动处理位操作，同时保留枚举的模式匹配优势。

具体实现思路 #

1. 用#[repr(u8)]强制枚举使用u8作为判别式类型，避免默认的isize带来的额外字节开销。
2. 将变体的判别式指定为占用数据的最高位（或最低位），确保原始结构体的7位数据与判别位不重叠。
3. 封装转换方法时，通过掩码确保原始结构体的数值仅使用低7位，避免数据冲突。

示例代码（安全实现） #

#[repr(transparent)]
struct TypeFlags(u8);

impl std::ops::BitOr for TypeFlags {
    type Output = Self;

    fn bitor(self, rhs: Self) -> Self::Output {
        Self(self.0 | rhs.0)
    }
}

#[repr(transparent)]
struct Control(u8);

// 用#[repr(u8)]限定判别式为u8，手动指定判别位为最高位
#[repr(u8)]
enum PackedEither {
    Type(TypeFlags),
    Ctrl(Control),
}

impl PackedEither {
    // 从TypeFlags转换为PackedEither
    fn from_type(tf: TypeFlags) -> Self {
        // 确保TypeFlags未使用最高位
        debug_assert_eq!(tf.0 & 0x80, 0);
        PackedEither::Type(TypeFlags(tf.0))
    }

    // 从Control转换为PackedEither
    fn from_ctrl(ctrl: Control) -> Self {
        // 确保Control未使用最高位
        debug_assert_eq!(ctrl.0 & 0x80, 0);
        PackedEither::Ctrl(Control(ctrl.0 | 0x80))
    }

    // 解构为易于模式匹配的Either类型
    fn unpack(self) -> core::result::Result<TypeFlags, Control> {
        match self {
            PackedEither::Type(tf) => Ok(TypeFlags(tf.0 & 0x7F)),
            PackedEither::Ctrl(ctrl) => Err(Control(ctrl.0 & 0x7F)),
        }
    }
}

// 验证大小：确实为1字节
static_assertions::const_assert_eq!(std::mem::size_of::<PackedEither>(), 1);

关键点说明 #

• #[repr(u8)]是实现1字节大小的核心，它强制枚举的判别式占用1字节，而非默认的指针大小。
• 用最高位（0x80）作为变体判别位，原始结构体的数值仅使用低7位（通过0x7F掩码过滤），确保数据与判别位不冲突。
• 封装的转换和解构方法让外部代码无需手动处理位操作，同时保留枚举的模式匹配便利性。

内容的提问来源于stack exchange，提问作者kalkronline