A Boolean is a true/false value. It can only be those two values and there be represented by a single bit (1 or 0).

In most languages a Boolean variable occupies the space of a full byte (8 bit) even though only a single of those bits is needed for representing the Boolean.

That’s mostly because computers can’t load a bit. They can only load bytes. Your memory is a single space where each byte has a numeric address. Starting from 0 and going to whatever amount of memory you have available. This is not really true because on most operating systems each process gets a virtual memory space but its true for many microcontrollers. You can load and address each f these bytes but it will always be a byte. That’s why booleans are stored as bytes because youd have to pack them with other data on the same address other wise and that’s getting complicated.

Talking about getting complicated, in C++ a std::vector<bool> is specialized as a bit field. Each of the values in that vector only occupy a single bit and you can get a vector of size 8 in a single byte. This becomes problematic when you want to store references or pointers to one of the elements or when you’re working with them in a loop because the elements are not of type bool but some bool-reference type.

A boolean value only needs 1 bit (on or off) for true or false. However the smallest bit of addressable memory is a byte (8 bits) hence 7 are technically wasted.

For low memory devices you could instead store 8 different Boolean values in one single byte by using bit masking instead

what about them?

I first thought you wrote boolean float, not sure if that’s even worse.

CPUs don’t read one bit a a time.

It would be slower to read the value if you had to also do bitwise operations to get the value.

But you can also define your own bitfield types to store booleans packed together if you really need to. I would much rather that than have the compiler do it automatically for me.

Well there are containers that store booleans in single bits (e.g. std::vector<bool> - which was famously a big mistake).

But in the general case you don’t want that because it would be slower.

Consider what the disassembly would look like. There’s no fast way to do it.

It’s also unnecessary since 8 bytes is a negligible amount in most cases. Serialization is the only real scenario where it matters. (Edit: and embedded)

Edit - oops, responded to wrong comment…

Okay. Gen z programmer here. Can you explain this black magic? I see it all the time in kernel code but I have no idea what it means.

With embedded stuff its still done like that. And if you go from the arduino functionss to writing the registers directly its a hell of a lot faster.

This was gonna be my response to OP so I’ll offer an alternative approach instead:

typedef enum flags_e : unsigned char {
  F_1 = (1 << 0),
  F_2 = (1 << 1),
  F_3 = (1 << 2),
  F_4 = (1 << 3),
  F_5 = (1 << 4),
  F_6 = (1 << 5),
  F_7 = (1 << 6),
  F_8 = (1 << 7),
} Flags;

int main(void) {
  Flags f = F_1 | F_3 | F_5;
  if (f & F_1 && f & F_3) {
    // do F_1 and F_3 stuff
  }
}

Or just std::bitset<8> for C++. Bit fields are neat though, it can store weird stuff like a 3 bit integer, packed next to booleans

You beat me to it!

01111111 = true

11111111 = negative true = false

TIL, 255 is the new 1.

Aka -1 >> 1 : TRUE

I was programming in assembly for ARM (some cortex chip) and I kid you not the C program we were integrating with required 255, with just 1 it read it as false

You jest, but on some older computers, all ones was the official truth value. Other values may also have been true in certain contexts, but that was the guaranteed one.

No it isn’t. All statically typed languages I know of use a byte. Which languages store it in an entire 32 bits? That would be unnecessarily wasteful.