How does a C-style struct with a bitfield get represented in a Rust #[repr(C)] struct?

I have a C struct defined as:

struct my_c_s {
    u_char          *ptr;
    unsigned        flag_a:1;
    unsigned        flag_b:1;
    int             some_num;
}

How would flag_a and flag_b be represented?

#[repr(C)]
pub struct my_rust_s {
    pub ptr: *const u_char,
    //pub flag_a: ?,
    //pub flag_b: ?,
    pub some_num: ::libc::c_int,
}

Can I declare them as bools? Or does that whole thing need to be some sort of set of bits with a single field, and then I bitmask them out?

e.g. pub flag_bits: ::libc::c_uint,

Solution 1:

No, you can't.

There is an open issue about supporting bitfields, which doesn't seem to be active. In the issue, @retep998 explains how bitfields are handled in winapi. That might be helpful if you need to handle bitfields in C interface.

OP seems to aim at C interoperation, but if you just need bitfields functionality, there are several solutions.

• You should always consider simple redundant solution: avoid bitfields and let fields align naturally.
• bitfield, according to the comment -- I didn't know that, but it seems to provide C bitfields equivalent.
• bitflags. This seems suitable for bit-based flags, which typically represented as enum in C.
• #[repr(packed)] if you just want to pack fields to some degree, ignoring alignment. The fields will still be aligned to byte boundary.
• bit-vec if you need homogenious arrays of bits.