C++ のビットフィールドを Rust で再現してみた

101 1 1010 01111111

#include <array>
#include <bit>
#include <cstddef>
#include <cstdint>
#include <iomanip>
#include <iostream>

struct Header {
  std::uint16_t message_type : 4;
  std::uint16_t compressed : 1;
  std::uint16_t version : 3;
  std::uint16_t payload_len : 8;
};

int main() {
  Header header{.message_type = 10,
                .compressed = 1,
                .version = 5,
                .payload_len = 0x7f};
  const auto bytes = std::bit_cast<std::array<std::byte, sizeof(Header)>>(header);

  std::cout << "size=" << sizeof(Header) << " alignment=" << alignof(Header)
            << '\n';
  std::cout << "fields=" << header.version << ',' << header.compressed << ','
            << header.message_type << ',' << header.payload_len << '\n';
  std::cout << "object bytes=";
  for (const auto byte : bytes) {
    std::cout << ' ' << std::hex << std::setw(2) << std::setfill('0')
              << std::to_integer<unsigned int>(byte);
  }
  std::cout << '\n';
}

c++ -std=c++20 -Wall -Wextra -pedantic bitfield.cpp -o cpp-bitfield
./cpp-bitfield

size=2 alignment=2
fields=5,1,10,127
object bytes= ba 7f

use std::mem::{align_of, size_of};

struct RustHeader {
    version: u8,
    compressed: bool,
    message_type: u8,
    payload_len: u8,
}

#[repr(C)]
struct CHeader {
    version: u8,
    compressed: bool,
    message_type: u8,
    payload_len: u8,
}

#[repr(C, packed)]
struct PackedHeader {
    version: u8,
    compressed: bool,
    message_type: u8,
    payload_len: u8,
}

fn print_layout<T>(name: &str) {
    println!(
        "{name}: size={} bytes, alignment={} byte(s)",
        size_of::<T>(),
        align_of::<T>()
    );
}

fn main() {
    print_layout::<RustHeader>("repr(Rust)");
    print_layout::<CHeader>("repr(C)");
    print_layout::<PackedHeader>("repr(C, packed)");
}

repr(Rust): size=4 bytes, alignment=1 byte(s)
repr(C): size=4 bytes, alignment=1 byte(s)
repr(C, packed): size=4 bytes, alignment=1 byte(s)

#[repr(C, packed)]
struct PackedHeader {
    tag: u8,
    payload_len: u16,
}

fn main() {
    let header = PackedHeader {
        tag: 1,
        payload_len: 256,
    };
    let payload_len = &header.payload_len;

    println!("{payload_len}");
}

error[E0793]: reference to field of packed struct is unaligned
  --> packed-field-reference.rs:12:23
   |
12 |     let payload_len = &header.payload_len;
   |                       ^^^^^^^^^^^^^^^^^^^

#[derive(Debug, PartialEq)]
pub struct Header {
    pub version: u8,
    pub compressed: bool,
    pub message_type: u8,
    pub payload_len: u8,
}

#[derive(Debug, PartialEq)]
pub enum EncodeError {
    VersionOutOfRange(u8),
    MessageTypeOutOfRange(u8),
}

impl Header {
    pub fn encode(&self) -> Result<[u8; 2], EncodeError> {
        if self.version > 0b111 {
            return Err(EncodeError::VersionOutOfRange(self.version));
        }
        if self.message_type > 0b1111 {
            return Err(EncodeError::MessageTypeOutOfRange(self.message_type));
        }

        let packed = (u16::from(self.version) << 13)
            | (u16::from(self.compressed) << 12)
            | (u16::from(self.message_type) << 8)
            | u16::from(self.payload_len);

        Ok(packed.to_be_bytes())
    }

    pub fn decode(bytes: [u8; 2]) -> Self {
        let packed = u16::from_be_bytes(bytes);

        Self {
            version: ((packed >> 13) & 0b111) as u8,
            compressed: ((packed >> 12) & 0b1) != 0,
            message_type: ((packed >> 8) & 0b1111) as u8,
            payload_len: (packed & 0xff) as u8,
        }
    }
}

Header: size=4 bytes, alignment=1 byte(s)
wire length: 2 bytes
wire bytes: [ba, 7f]
wire bits:  1011101001111111
decoded: Header { version: 5, compressed: true, message_type: 10, payload_len: 127 }

#[test]
fn encodes_known_header_to_expected_bytes() {
    let header = Header {
        version: 5,
        compressed: true,
        message_type: 10,
        payload_len: 0x7f,
    };

    assert_eq!(header.encode(), Ok([0xba, 0x7f]));
}

#[test]
fn round_trips_all_valid_headers() {
    for version in 0..=0b111 {
        for compressed in [false, true] {
            for message_type in 0..=0b1111 {
                for payload_len in 0..=0xff {
                    let header = Header {
                        version,
                        compressed,
                        message_type,
                        payload_len,
                    };

                    assert_eq!(Header::decode(header.encode().unwrap()), header);
                }
            }
        }
    }
}

running 6 tests
test result: ok. 6 passed; 0 failed; 0 ignored