Bitwise Operators and Bit Flags

Behind the scenes, every variable and object we create when programming is stored in binary. That is a series of binary digits (bits), where each bit can have one of only two possible values. The possible values are on or off - typically represented by 1 or 0

Generally, we don’t need to work on this level. Our compilers and interpreters just abstract this away so we’re acting on higher-level objects, like numbers and strings.

But, there are some use cases where working at the level of individual bits unlocks some new possibilities for us. We’ll introduce those in this lesson.

Fixed Width Integers

Whenever we’re selecting a data type that we’ll be working with at the level of individual bits, it is common to choose a fixed-width unsigned integer. In this lesson, we’ll use uint8_t, which is available by including <cstdint>.

Fixed-width integers behave in the same way as int. The only difference is that the language specification prescribes exactly how "wide" (that is, how many bits) are used in a fixed-width type. The width of an int can be different on different platforms - it might be 16 bits, 32 bits, 64 bits.

uint8_t uses 8 bits on all platforms. Numerically, this means it supports values in the range 0-255.

Below, we show the underlying binary representation of these numbers using std::format, which we covered in a previous lesson:

String Interpolation

A detailed guide to string formatting using C++20's std::format(), and C++23's std::print()

We can output the binary form of an integer using the :b format specifier. In the following example, we extend this to :08b, representing we want our output to have a width of 8 and with additional 0s used to left-pad as necessary.

1#include <cstdint>
2#include <format>
3#include <iostream>
4
5int main() {
6  uint8_t i{0};
7  while (true) {
8    std::cout
9      << std::format("\n{0:<3} = {0:08b}", i++);
10
11    // Stop when i wraps around to 0
12    if (i == 0) break;
13  }
14}

This program outputs the numbers from 0-255 as well as their bits, which we’ve truncated below:

10   = 00000000
21   = 00000001
32   = 00000010
43   = 00000011
54   = 00000100
6[...]
7252 = 11111100
8253 = 11111101
9254 = 11111110
10255 = 11111111

Bitwise Operators

The operators that work on individual bits are called bitwise operators. We’ll introduce the three most useful bitwise operators in this lesson, which closely relate to boolean logic.

We previously saw how the || and && operators can be used to combine booleans in different ways.

These are called the "logical OR" and "logical AND" operators. They have their bitwise counterparts:

• the bitwise OR operator - C++ and many other programming languages represent this by a single |
• the bitwise XOR (exclusive or) operator - typically represented by a caret: ^
• the bitwise AND - typically represented by a single &

The Bitwise OR Operator: |

The bitwise OR operator looks at the binary representation of its two operands and returns a new object of the same type. Every bit in this new object is set to 1 if either of the operands had a 1 in that same position.

It’s easier to demonstrate with a diagram:

The Bitwise XOR (exclusive or) Operator: ^

XOR works very similarly to OR. The only difference is that, when both operands had a 1 in the same position, the result of XOR will have a 0 in that corresponding position.

Another way to think of XOR is that it will have 1 in each position where the operands have different values.

Here’s an example:

The Bitwise AND Operator: &

Similarly, the bitwise AND operator looks at the binary representation of its two operands and returns a new object of the same type. Every bit in this new object is set to 1 if both of the operands have a 1 in that same position.

Here’s an example:

Use Case: Bit Flags

In the next course, we’re going to be using a library that makes heavy use of bitwise operations in its API. For example, it allows us to create a window and gives us a range of options on how that window should behave.

These are all flags that we can enable or disable. covering things like:

• Is the window resizable?
• Is the window full-screen?
• Is the window movable?
• Is it always on top of other windows?

Without bitwise operators, there would be two main ways we would create this. We could just set our function up to receive a collection of booleans:

1CreateWindow(false, true, true, false, true);

But this is not a particularly good design, as we can’t easily read the behavior. What flags are we setting to be true here? That’s unclear, especially when we don’t have IDE tooltips to help us.

Alternatively, we could gather all of our booleans into a user-defined type, and then pass an object of that type to our function:

1struct WindowSettings {
2  bool Fullscreen{false};
3  bool Resizable{false};
4  bool Movable{false};
5  bool AlwaysOnTop{false};
6  bool Closable{false};
7};
8
9int main(){
10  WindowSettings Settings;
11  Settings.Resizable = true;
12  Settings.Movable = true;
13  Settings.Closable = true;
14
15  CreateWindow(Settings);
16}

This makes it clearer what flags we’re setting, but is quite verbose, and may have a performance overhead.

The best approach for this is often to use bit flags, and bitwise operators can help us implement them.

Using Bitwise Operators for Bit Flags

With bitwise operators, we could make our API much cleaner:

1CreateWindow(RESIZABLE | MOVABLE | CLOSABLE);

There are many ways to make this work. The standard library comes with a std::bitset class to solve this problem. Many others use an elaborate solution that involves enums.

Here, we’ll do a basic, raw implementation using integers, so we can fully understand what is going on at a deep level.

The first step is to choose a numeric type for our flags. We want our type to have enough bits to cover every possible flag. A uint8_t has 8 bits, which can accommodate 8 flags.

We don’t need to use every bit - if we just need 5 flags for example, we can still use an 8-bit type - we simply ignore 3 of the bits.

Next, we need to choose a distinct value for each of our flags. Given we’re using an integer, each value will be a number.

Each number we choose needs to have a single bit set to 1, with all the others being 0. The pattern that achieves this starts at 1, and each subsequent number is double the previous.

That is, 1, 2, 4, 8, 16, 32, and so on. The following program demonstrates this:

1#include <cstdint>
2#include <format>
3#include <iostream>
4
5int main() {
6  for (uint8_t i:{1, 2, 4, 8, 16, 32, 64, 128}){
7    std::cout
8      << std::format("{0:<3} = {0:08b}", i)
9      << '\n';
10  }
11}

11   = 00000001
22   = 00000010
34   = 00000100
48   = 00001000
516  = 00010000
632  = 00100000
764  = 01000000
8128 = 10000000

Next, we give each number in our sequence a descriptive name, which will be the flag it represents.

Typically we’d also include the number 0, which has every bit set to 0. We use this to represent the absence of any flags - that is, the equivalent of everything being false:

1#include <cstdint>
2
3const uint8_t NONE{0};           // 00000000
4const uint8_t RESIZABLE{1};      // 00000001
5const uint8_t MOVABLE{2};        // 00000010
6const uint8_t CLOSABLE{4};       // 00000100
7const uint8_t FULLSCREEN{8};     // 00001000
8const uint8_t ALWAYS_ON_TOP{16}; // 00010000

This doubling pattern can continue if we need more flags. If we need more than 8 flags, we’d need to switch to a type that has more than 8 bits. For example, uint16_t, uint32_t, and uint64_t are also available.

We can now combine our flags in any way we want using the bitwise OR operator |. We show some examples below, where every flag we enable sets a bit in our uint8_t to 1:

1#include <cstdint>
2#include <format>
3#include <iostream>
4
Flags|Show
5const uint8_t NONE{0};
12
13void CreateWindow(uint8_t flags = NONE) {
14  std::cout <<
15    std::format("\nFlags: {0:08b}", flags);
16}
17
18int main() {
19  // Set one bit to 1
20  CreateWindow(CLOSABLE);
21
22  // Set two bits to 1
23  CreateWindow(FULLSCREEN | ALWAYS_ON_TOP);
24
25  // Set three bits to 1
26  CreateWindow(MOVABLE | CLOSABLE | RESIZABLE);
27}

1Flags: 00000100
2Flags: 00011000
3Flags: 00000111

Checking if a Bit Flag was set

In the function that receives our bit flags, we can determine which flags were set using the bitwise & operator. For example, to check if the CLOSABLE flag was set, we can do this:

1#include <cstdint>
2#include <format>
3#include <iostream>
4
Flags|Show
5const uint8_t NONE{0};
12
13void CreateWindow(uint8_t flags = NONE) {
14  std::cout <<
15    std::format("\nFlags: {0:08b}", flags);
16  if (flags & CLOSABLE) {
17    std::cout << "\nCLOSABLE was set\n";
18  } else {
19    std::cout << "\nCLOSABLE was NOT set\n";
20  }
21}
22
23int main() {
24  CreateWindow(CLOSABLE);
25  CreateWindow(FULLSCREEN | ALWAYS_ON_TOP);
26  CreateWindow(MOVABLE | CLOSABLE | RESIZABLE);
27}

1Flags: 00000100
2CLOSABLE was set
3
4Flags: 00011000
5CLOSABLE was NOT set
6
7Flags: 00000111
8CLOSABLE was set

It’s likely to be unclear why this works, but it’s important to understand what flags & CLOSABLE is doing.

The CLOSABLE variable sets a single bit set to 1. Specifically, CLOSABLE is 00000100 - that is, the 3rd bit from the right is set to 1

Therefore, given how the bitwise & works, there are only two possible outcomes when one of the operands is 00000100:

• If the other operand - flags in this case - also has a 1 in that position, the & operator will return 00000100. This is equivalent to the numeric value 4. 4, and any other non-zero number, is true when treated as a boolean
• If the other operand - flags in this case - has a 0 in that position, the & operator will return 00000000. This is equivalent to the numeric value 0. 0 is false when treated as a boolean

The net effect of all of this is that the flags & CLOSABLE expression will be truthy only if flags has its third bit from the right set to 1.

An expression like MOVABLE | CLOSABLE | RESIZABLE generates a value with that bit set to 1, whilst the value returned from an expression like FULLSCREEN | ALWAYS_ON_TOP will have the bit set to 0

Full Example

Below, we’ve hooked up all of our flags:

1#include <cstdint>
2#include <iostream>
3
Flags|Show
4const uint8_t NONE{0};
11
12void CreateWindow(
13  std::string Title, uint8_t flags = NONE
14) {
15  std::cout << Title << " has these flags:";
16  if (flags == NONE) {
17    std::cout << " NONE";
18  }
19  if (flags & RESIZABLE) {
20    std::cout << " RESIZABLE";
21  }
22  if (flags & MOVABLE) {
23    std::cout << " MOVABLE";
24  }
25  if (flags & CLOSABLE) {
26    std::cout << " CLOSABLE";
27  }
28  if (flags & FULLSCREEN) {
29    std::cout << " FULLSCREEN";
30  }
31  if (flags & ALWAYS_ON_TOP) {
32    std::cout << " ALWAYS_ON_TOP";
33  }
34  std::cout << '\n';
35}
36
37int main() {
38  CreateWindow("Window A");
39  CreateWindow("Window B", FULLSCREEN);
40  CreateWindow("Window C", RESIZABLE | MOVABLE);
41}

1Window A has these flags: NONE
2Window B has these flags: FULLSCREEN
3Window C has these flags: RESIZABLE MOVABLE

Summary

In this lesson, we explored the intricacies of bitwise operators and bit flags and their practical applications in programming. Through detailed examples and explanations, we've equipped you with the knowledge to utilize these operators effectively in your projects.

Key Takeaways

• Understanding Bitwise Operators: Learned about the bitwise OR, AND, and XOR operators, and how they manipulate individual bits in binary representations of integers.
• Fixed Width Integers: Gained insights into using fixed-width integers like uint8_t for predictable, platform-independent bit manipulations.
• Bit Flags in Practice: Explored the practical application of bitwise operators for managing bit flags, a common technique in configuring settings or options compactly.

Part 2 - Available Now

Professional C++

Advance straight from the beginner course, dive deeper into C++, and learn expert workflows

View Course