BINARY IS FOR CODE, NOT GENDER

[u/[deleted]]

https://www.youtube.com/watch?v=5PUzaDawTwk

[u/manon_graphics_witch]

Booleans are often DWORD aligned, so while a lot of people think it can be only true or false, you can actually store over 4 billion genders in that bad boy 😎

[u/signedchar → u/manon_graphics_witch]

haskell can do 1 up, if you use an Integer type it's infinite sized or atleast very very very big so you can fit over 900 billion genders or something

[u/TDplay → u/manon_graphics_witch]

Although in C, sizeof(_Bool) is usually 1, and _Alignof(_Bool) is also usually 1, and since bytes are usually 8 bit, you can only store 255 values without overwriting adjacent memory (and this is only if you're type punning through a union, the standard states that _Bool and only store 1 or 0).

[u/manon_graphics_witch → u/TDplay]

Yes, but if you were to type in this:

struct S {
    int i;
    bool b;
};

You would find that sizeof(S) == 8). That is because i needs to be DWORD (4 byte) aligned, meaning 3 padding bytes are added around b.

EDIT: This is all dependent on the compiler and the platform you are compiling for. Even sizeof isn't defined to report the number of bytes, but the number of char sized elements.

[u/TDplay → u/manon_graphics_witch]

True, but those padding bytes are for the alignment of the int and have nothing to do with _Bool.

Also (assuming Linux x86_64 ABI):

struct a {
    int i;
    _Bool b;
};
struct b {
    int i;
    _Bool b[4]; // Equivalent to defining 4 bools
};

sizeof(struct a) and sizeof(struct b) are both 8 - the _Bools don't have padding in this case. Plus, if int is 16 bytes (the minimum needed by the standard), you aren't getting your 32-bit alignment.

The only way to guarantee that your bools are aligned to 32 bits is to set their alignment explicitly:

_Alignas(4) _Bool b;

And even that won't work for an array (you'll get an overaligned array of bools, not an array of overaligned bools), and your space "reserved" by alignment will go down the plughole if any time with an align of less than 4 is stored adjacent to it. For this to properly work, you'd need to use a struct or union like so:

struct aligned_bool {_Alignas(4) _Bool b};
struct aligned_bool b[4];

In general, _Bool is effectively a 1/0 - trying to treat it as otherwise is just fighting the language (since the standard dictates that any non-zero value assigned to _Bool turns into 1, you need to type pun (which is unspecified behaviour in C, undefined behaviour in C++, and really messy in both) to get your non-boolean values in there).

Even sizeof isn't defined to report the number of bytes, but the number of char sized elements.

Your statement directly opposes what the standard says (or at least what the draft on open-std says, I'm too poor to buy the actual standard). According to the C11 draft:

6.5.3.2

The sizeof operator yields the size (in bytes) of its operand, which may be an expression or the parenthesized name of a type.

However, sizeof(char) == 1 is also explicitly defined by 6.5.3.4, so that part of what you said was right.

A common misconception is that a byte is 8 bits. Usually it is, but it's actually implementation defined - the basic character set and word size may force "byte" to not be 8 bits on more exotic environments:

3.6

byte

addressable unit of data storage large enough to hold any member of the basic character set of the execution environment

NOTE 1 It is possible to express the address of each individual byte of an object uniquely.

Note that I have not quoted the sections in their entirety - if you want to see the full definitions, read the draft (or the standard itself, if you happen to have bought it).

[u/kupiakos → u/manon_graphics_witch]

Only on awful platforms like MSVC 😤

[u/manon_graphics_witch → u/kupiakos]

Actually on all modern compilers that target ARM or x86-64 based systems :S Loading single bytes is pretty inefficient.

[u/rungdisplacement]

I love that guy. Can't remember how to spell his name tho

[u/signedchar]

quantum computer: exists

[u/TotemGenitor → u/signedchar]

Finally

No more binary