• timhh@programming.dev
    link
    fedilink
    arrow-up
    1
    ·
    2 days ago

    things that store it as word size for alignment purposes

    Nope. bools only need to be naturally aligned, so 1 byte.

    If you do

    struct SomeBools {
      bool a;
      bool b;
      bool c;
      bool d;
    };
    

    its 4 bytes.

    • brian@programming.dev
      link
      fedilink
      arrow-up
      1
      ·
      2 days ago

      sure, but if you have a single bool in a stack frame it’s probably going to be more than a byte. on the heap definitely more than a byte

      • timhh@programming.dev
        link
        fedilink
        arrow-up
        1
        arrow-down
        1
        ·
        17 hours ago

        but if you have a single bool in a stack frame it’s probably going to be more than a byte.

        Nope. - if you can’t read RISC-V assembly, look at these lines

                sb      a5,-17(s0)
        ...
                sb      a5,-18(s0)
        ...
                sb      a5,-19(s0)
        ...
        

        That is it storing the bools in single bytes. Also I only used RISC-V because I’m way more familiar with it than x86, but it will do the same thing.

        on the heap definitely more than a byte

        Nope, you can happily malloc(1) and store a bool in it, or malloc(4) and store 4 bools in it. A bool is 1 byte. Consider this a TIL moment.

        • brian@programming.dev
          link
          fedilink
          arrow-up
          1
          ·
          36 seconds ago

          c++ guarantees that calls to malloc are aligned https://en.cppreference.com/w/cpp/memory/c/malloc .

          you can call malloc(1) ofc, but calling malloc_usable_size(malloc(1)) is giving me 24, so it at least allocated 24 bytes for my 1, plus any tracking overhead

          yeah, as I said, in a stack frame. not surprised a compiler packed them into single bytes in the same frame (but I wouldn’t be that surprised the other way either), but the system v abi guarantees at least 4 byte alignment of a stack frame on entering a fn, so if you stored a single bool it’ll get 3+ extra bytes added on the next fn call.

          computers align things. you normally don’t have to think about it. Consider this a TIL moment.