Why Booleans Take a Byte of Memory

This is a great question! Even though a boolean only needs a single bit (0 or 1) to store its value, in C++ and most other programming languages, booleans typically use a whole byte of memory. Let's explore why this design decision was made.

Memory Access Efficiency

Modern computers are designed to access memory in chunks of bytes (8 bits), not individual bits. Trying to access individual bits would actually be slower than accessing whole bytes, because the computer would need to do extra work to figure out which bit to read or write.

Think of it like a library where books can only be accessed by shelf, not individually. Even if you only want one page from a book, you need to take the whole book off the shelf.

Here's a simple program that shows us the size of a boolean:

1#include <iostream>
2using namespace std;
3
4int main() {
5  bool isAlive{true};
6  cout << "Size of bool: "
7    << sizeof(isAlive) << " byte\n";
8
9  // We can have an array of booleans
10  bool flags[8]{true, false, true,
11    true, false, false, true, false};
12  cout << "Size of 8 bools: "
13    << sizeof(flags) << " bytes";
14}

1Size of bool: 1 byte
2Size of 8 bools: 8 bytes

Memory Alignment

Another reason for using a whole byte is memory alignment. Modern computers work most efficiently when data is aligned on certain boundaries. Using full bytes helps maintain this alignment without requiring special handling.

Space vs Speed Tradeoff

While it might seem wasteful to use 8 bits when we only need 1, the performance benefits of byte-aligned access usually outweigh the memory cost. In most programs, the extra memory used by booleans is negligible compared to other data types like integers (4 bytes) and floating-point numbers (4 or 8 bytes).

If you do need to store many boolean values efficiently, C++ provides special container types like std::vector<bool> which we'll learn about later that can pack multiple boolean values into single bytes.