Why _Bool and bool instead of int8_t or char?

Question

I came up with a thought about the types of _Bool/ bool (stdbool.h) in C and bool in C++.

We use the boolean types to declare objects, that only shall hold the values of 0 or 1. For example:

_Bool bin = 1;

or

bool bin = 1;

(Note: bool is a macro for _Bool inside the header file of stdbool.h.)

in C,

or

bool bin = 1;

in C++.

But are the boolean types of _Bool and bool really efficient?

I made a test to determine the size of each object in memory:

For C:

#include <stdio.h>
#include <stdbool.h>   // for "bool" macro.

int main()
{
    _Bool bin1 = 1;
    bool bin2 = 1; // just for the sake of completeness; bool is a macro for _Bool.    

    printf("the size of bin1 in bytes is: %lu \n",(sizeof(bin1)));
    printf("the size of bin2 in bytes is: %lu \n",(sizeof(bin2)));  

    return 0;
}

Output:

the size of bin1 in bytes is: 1
the size of bin2 in bytes is: 1

For C++:

#include <iostream>

int main()
{
    bool bin = 1;

    std::cout << "the size of bin in bytes is: " << sizeof(bin);

    return 0;
}

Output:

the size of bin in bytes is: 1

So, objects of a boolean type do get stored inside 1 byte (8 bits) in memory, not just in one 1 bit, as it normally only shall require.

The reason why is discussed here: Why is a char and a bool the same size in c++?. This is not what my question is about.

My question are:

Why do we use the types of _Bool/ bool (stdbool.h) in C and bool in C++, if they do not provide a benefit in memory storage, as it is specificially pretended for use these types?
Why can´t I just use the types of int8_t or char (assuming char is contained of 8 bit (which is usually the case) in the specific implementation) instead?

Is it just to provide the obvious impression for a reader of the code, that the respective objects are used for 0 or 1/true or false purposes only?

Thank you very much to participate.

Well, from personal experience, I once came up with a test case where the proper usage of `bool` have actually reduced the code size versus the counterpart using `int`. Unfortunately can't recall the details. — Eugene Sh., Jan 22 '20 at 14:34
You can use [bitfields](https://www.geeksforgeeks.org/bit-fields-c/) if you're concerned about wasting bits. — Fiddling Bits, Jan 22 '20 at 14:35
*Is it just to provide the obvious impression for a reader of the code, that the respective objects are used for 0 or 1/true or false purposes only?* That is one major benefit. — NathanOliver, Jan 22 '20 at 14:37
Funny enough, even with such a simple example there is a slight difference: https://godbolt.org/z/6GGwGy — Eugene Sh., Jan 22 '20 at 14:37
@EugeneSh. But I do not refer to `int`. I refer to `int8_t` and `char`. — RobertS supports Monica Cellio, Jan 22 '20 at 14:39
I do use `bool` to use `true` and `false` **instead of** `0` and `1`. If you think `1` and `0` is fine you dont really need `bool` — 463035818_is_not_an_ai, Jan 22 '20 at 14:39
Partially. It's one of the reasons to have an explicit type just for truthiness. formerlyknownas covers another one. — NathanOliver, Jan 22 '20 at 14:43
But again, the types are treated differently, not necessarily w.r.t. to storage, they provide different behavior and functionality. For example try to do `b++` on boolean. The result will be completely different from other integer types. — Eugene Sh., Jan 22 '20 at 14:45
@formerlyknownas_463035818 But I can use the macros of `true` and `false` also with `int8_t` or `char` if I prodived the respective macro definitions, either in a standard library header or by myself: `#define true 0` `#define wrong 0`, `int8_t bin = true` or `char bin = true`. — RobertS supports Monica Cellio, Jan 22 '20 at 14:48
@NathanOliver So it's even more difference- type checking is quite important. — Eugene Sh., Jan 22 '20 at 14:48
Don't forget, since `bool` is a different type of `uint8_t`, some template may behave differently. (Yes, I look at you `std::vector`) — Martin Morterol, Jan 22 '20 at 14:48
@MartinMorterol Don't look too hard. It tends to bite when you do ;) — NathanOliver, Jan 22 '20 at 14:50
@FiddlingBits But aren´t the other 7 bits padded for data alignment if I use bitfields? — RobertS supports Monica Cellio, Jan 22 '20 at 14:51
@RobertS-ReinstateMonica Sure, but why would you? I dont know anything that you cannot spice up with a macro, but I know only few cases where I would allow a macro. — 463035818_is_not_an_ai, Jan 22 '20 at 14:52
@Blastfurnace Why do I use the `_Bool` and `bool` types instead of `int8_t` or `char`? — RobertS supports Monica Cellio, Jan 22 '20 at 14:53
@formerlyknownas_463035818 This implies that there is difference when I use `true`or `false` with boolean types in comparison to when I use these with `char` or `int8_t`. Could you state this difference? That would be great. — RobertS supports Monica Cellio, Jan 22 '20 at 14:57
wrong ping? " This implies that there..." dont know what you refer to — 463035818_is_not_an_ai, Jan 22 '20 at 14:57
@formerlyknownas_463035818 No, right ping. You said *I do use bool to use true and false instead of 0 and 1. If you think 1 and 0 is fine you dont really need bool*. on which I replied: *But I can use the macros of true and false also with int8_t or char* - Why do you prefer to use the macros of `true` and `false` with `bool` only? Is there a specific relation from these macros to the type of `bool`, which `int8_t` and `char` do not have? — RobertS supports Monica Cellio, Jan 22 '20 at 15:11
@RobertS-ReinstateMonica That's true. What I meant was that you could use all the bits separately for true/false (i.e. instead of eight `bool`s you can use eight bits in a bitfield). — Fiddling Bits, Jan 22 '20 at 15:53
@RobertS-ReinstateMonica ah ok, I dont know C, in C++ `true` and `false` are no macros — 463035818_is_not_an_ai, Jan 22 '20 at 18:35

eerorika · Accepted Answer · 2020-01-22T15:07:27.690

Why do we use the types of _Bool/ bool (stdbool.h) in C and bool in C++, if they do not provide a benefit in memory storage, as it is specificially pretended for use these types?

You already mentioned the reason in your question:

We use the boolean types to declare objects, that only shall hold the values of 0 or 1

The advantage of using boolean datatype specifically is because it can only represent true or false. The other integer types have more representable values which is undesirable when you want only two.

Why can´t I just use the types of int8_t or char (assuming char is contained of 8 bit (which is usually the case) in the specific implementation) instead?

You can. In fact, C didn't have a boolean data type until C99 standard. Note that downside of using int8_t is that it is not guaranteed to be provided by all systems. And porblem with char is that it may be either signed or unsigned.

But you don't need to, since you can use boolean data type instead.

This implies that there is difference when I use trueor false with boolean types in comparison to when I use these with char or int8_t. Could you state this difference?

Consider following trivial example:

int8_t i = some_value;
bool b = some_value;

if (i == true)
if (i)
if (b == true)
if (b)

For int8_t, those two conditionals have different behaviour, which creates opporunity for the behaviour to be wrong if the wrong form is chosen. For a boolean, they have identical behaviour and there is no wrong choice.

P.S. If you want to compactly store multiple boolean values (at the cost of multiple instructions per read and write), you can use std::bitset or std::vector<bool> for example. In C there are no analogous standard library utilities, but such functionality can be implemented with shifting and masking.

score 1 · Answer 2 · answered Jan 22 '20 at 14:54

There's more than one sort of efficiency. Memory efficiency is one. Speed efficiency is another.

The original C language did not have a boolean type at all -- typically a programmer would use an int for boolean flags, 0 for false and 1 for true. If they were really concerned about memory efficiency, they might use a bitmap to store eight booleans in a byte, but this was generally only necessary in situations where memory was really scarce. But accessing an int is faster than accessing an int then unpacking its constituent bits.

_Bool/bool was introduced in C99. It reflects the common practice of storing booleans in an int.

However, it has the advantage that the compiler knows it's a boolean, so it's more difficult to accidentally assign it the value 3, add it to an integer, etc.

Most programming languages today store a boolean in a byte. Yes, it uses eight times more memory than necessary -- but it's fast, and it's rare to have so many booleans on the go at once that the waste becomes significant.

In many programming languages, the implementation is separate from the language spec -- Javascript's spec doesn't say how the Javascript runtime should store true or false. In C99 however you can rely on true being equivalent to integer 1.

If booleans are truly using too much of your system's memory, you can work with bitwise operations to store 8 booleans in an unsigned char or more in the larger types.

You can do that for runtime operations if necessary, or just when writing to an output format (if the problem is the size of records on filesystems, or network packets).

It's worth noting though, that in many, many modern applications, people are perfectly happy to represent false on the wire or on the filesystem as the 7 bytes [ '"', 'f', 'a', 'l', 's', 'e', '"' ]

score 0 · Answer 3 · answered Jan 22 '20 at 15:51

One of the reasons for having bool as well as int is to increase the comprehensibility of the code to those who come after and try to maintain it.

Consider these

bool b; int c;

if (b == c)

c = 2; b = 2;

Now, I'd have said that comparing a boolean (true or false) with a number is very likely an error. So things like 'if (b == 1)' could indicate a coding error. I hope you'd agree that 'b = 2' is just wrong.

Benefits in memory storage (and I don't recall anything anywhere claiming that using boolean types reduced memory requirements) are not the only reason for language features.

Why _Bool and bool instead of int8_t or char?

3 Answers3