this post was submitted on 15 May 2025
0 points (NaN% liked)
Programmer Humor
24628 readers
344 users here now
Welcome to Programmer Humor!
This is a place where you can post jokes, memes, humor, etc. related to programming!
For sharing awful code theres also Programming Horror.
Rules
- Keep content in english
- No advertisements
- Posts must be related to programming or programmer topics
founded 2 years ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
And compiler. And hardware architecture. And optimization flags.
As usual, it's some developer that knows little enough to think the walls they see around enclose the entire world.
I don't think so. Apart from dynamically typed languages which need to store the type with the value, it's always 1 byte, and that doesn't depend on architecture (excluding ancient or exotic architectures) or optimisation flags.
Which language/architecture/flags would not store a bool in 1 byte?
things that store it as word size for alignment purposes (most common afaik), things that pack multiple books into one byte (normally only things like bool sequences/structs), etc
Nope. bools only need to be naturally aligned, so 1 byte.
If you do
its 4 bytes.
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
Nope. - if you can't read RISC-V assembly, look at these lines
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.
Nope, you can happily
malloc(1)
and store a bool in it, ormalloc(4)
and store 4 bools in it. A bool is 1 byte. Consider this a TIL moment.c++ guarantees that calls to malloc are aligned https://en.cppreference.com/w/cpp/memory/c/malloc .
you can call
malloc(1)
ofc, but callingmalloc_usable_size(malloc(1))
is giving me 24, so it at least allocated 24 bytes for my 1, plus any tracking overheadyeah, 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.