Tell me the truth ...

typedef struct {
    bool a: 1;
    bool b: 1;
    bool c: 1;
    bool d: 1;
    bool e: 1;
    bool f: 1;
    bool g: 1;
    bool h: 1;
} __attribute__((__packed__)) not_if_you_have_enough_booleans_t;

Depending on the language

I set all 8 bits to 1 because I want it to be really true.

string boolEnable = "True";

Then you need to ask yourself: Performance or memory efficiency? Is it worth the extra cycles and instructions to put 8 bools in one byte and & 0x bitmask the relevant one?

Wait till you find out about alignment and padding

Back in the day when it mattered, we did it like

#define BV00		(1 <<  0)
#define BV01		(1 <<  1)
#define BV02		(1 <<  2)
#define BV03		(1 <<  3)
...etc

#define IS_SET(flag, bit)	((flag) & (bit))
#define SET_BIT(var, bit)	((var) |= (bit))
#define REMOVE_BIT(var, bit)	((var) &= ~(bit))
#define TOGGLE_BIT(var, bit)	((var) ^= (bit))

....then...
#define MY_FIRST_BOOLEAN BV00
SET_BIT(myFlags, MY_FIRST_BOOLEAN)

The 8-bit Intel 8051 family provides a dedicated bit-addressable memory space (addresses 20h-2Fh in internal RAM), giving 128 directly addressable bits. Used them for years. I'd imagine many microcontrollers have bit-width variables.

bit myFlag = 0;

Or even return from a function:

bit isValidInput(unsigned char input) { // Returns true (1) if input is valid, false (0) otherwise return (input >= '0' && input <= '9'); }

In the industrial automation world and most of the IT industry, data is aligned to the nearest word. Depending on architecture, that's usually either 16, 32, or 64 bits. And that's the space a single Boolean takes.

Peasant...

https://github.com/aumuell/open-inventor/blob/014e2bf17f50f5d510cdd57744d03c436ee9ce27/lib/database/include/Inventor/SbBasic.h#L83

std::vector<bool> fits eight booleans into one byte.

It's far more often stored in a word, so 32-64 bytes, depending on the target architecture. At least in most languages.

if wasting a byte or seven matters to you, then then you need to be working in a lower level language.

Joke’s on you, I always use 64 bit wide unsigned integers to store a 1 and compare to check for value.

I have a solution with a bit fields. Now your bool is 1 byte :

struct Flags {
    bool flag0 : 1;
    bool flag1 : 1;
    bool flag2 : 1;
    bool flag3 : 1;
    bool flag4 : 1;
    bool flag5 : 1;
    bool flag6 : 1;
    bool flag7 : 1;
};

Or for example:

struct Flags {
    bool flag0 : 1;
    bool flag1 : 1:
    int x_cord : 3;
    int y_cord : 3;
};

True.

boolean bloat

just like electronic components, they sell the gates by the chip with multiple gates in them because it's cheaper

Are you telling me that no compiler optimizes this? Why?

Wait until you hear about alignment

This reminds me that I actually once made a class to store bools packed in uint8 array to save bytes.

Had forgotten that. I think i have to update the list of top 10 dumbest things i ever did.

Wait till you here about every ascii letter. . .

3GPP has an interesting way of serialising bools on the wire with ASN.1

NULL OPTIONAL

meaning only the type would be stored if true, otherwise it won't be set at all

This guy never coded in KEIL C on an 8051 architecture. They actually use bit addressable RAM for booleans. And if you set the compiler to pass function parameters in registers, it uses the carry flag for the first bit or bool type parameter.

...or you can be coding assembler - it's all just bits to me

Redundancy is nice in the event of bitflip errors

pragma(pack) {

int a:1, b:1, ... h:1;

}

IIRC.

I mean is it really a waste? What's minimum amount of bits most CPUs read in one cycle.

7 Shades of Truth

I swore I read that mysql dbs will store multiple bools in a row as bit maps in one byte. I can't prove it though

Could a kind soul ELI5 this? Well, maybe ELI8. I did quite a bit of programming in the 90-00s as part of my job, although nowadays I'm more of a script kiddie.

Pl/1 did it right:

Dcl 1 mybools, 3 bool1 bit(1) unaligned, 3 bool2 bit(1) unaligned, … 3 bool8 bit(1) unaligned;

All eight bools are in the same byte.

Now store the numbers (array):

0 0 0 1 0 1 1 2

think 8 bytes???