O.3 — Bit manipulation with bitwise operators and bit masks

By Alex on September 8th, 2015 | last modified by Alex on August 21st, 2019

In the previous lesson on bitwise operators (O.2 -- Bitwise operators), we discussed how the various bitwise operators apply logical operators to each bit within the operands. Now that we understand how they function, let’s take a look at how they’re more commonly used.

Bit masks

In order to manipulate individual bits (e.g. turn them on or off), we need some way to identify the specific bits we want to manipulate. Unfortunately, the bitwise operators don’t know how to work with bit positions. Instead they work with bit masks.

A bit mask is a predefined set of bits that is used to select which specific bits will be modified by subsequent operations.

Consider a real-life case where you want to paint a window frame. If you’re not careful, you risk painting not only the window frame, but also the glass itself. You might buy some masking tape and apply it to the glass and any other parts you don’t want painted. Then when you paint, the masking tape blocks the paint from reaching anything you don’t want painted. In the end, only the non-masked parts (the parts you want painted) get painted.

A bit mask essentially performs the same function for bits -- the bit mask blocks the bitwise operators from touching bits we don’t want modified, and allows access to the ones we do want modified.

Let’s first explore how to define some simple bit masks, and then we’ll show you how to use them.

Defining bit masks in C++14

The simplest set of bit masks is to define one bit mask for each bit position. We use 0s to mask out the bits we don’t care about, and 1s to denote the bits we want modified.

Although bit masks can be literals, they’re often defined as symbolic constants so they can be given a meaningful name and easily reused.

Because C++14 supports binary literals, defining these bit masks is easy:

constexpr unsigned char mask0 { 0b0000'0001 }; // represents bit 0

constexpr unsigned char mask1 { 0b0000'0010 }; // represents bit 1

constexpr unsigned char mask2 { 0b0000'0100 }; // represents bit 2

constexpr unsigned char mask3 { 0b0000'1000 }; // represents bit 3

constexpr unsigned char mask4 { 0b0001'0000 }; // represents bit 4

constexpr unsigned char mask5 { 0b0010'0000 }; // represents bit 5

constexpr unsigned char mask6 { 0b0100'0000 }; // represents bit 6

constexpr unsigned char mask7 { 0b1000'0000 }; // represents bit 7

Now we have a set of symbolic constants that represents each bit position. We can use these to manipulate the bits (which we’ll show how to do in just a moment).

Defining bit masks in C++11 or earlier

Because C++11 doesn’t support binary literals, we have to use other methods to set the symbolic constants. There are two good methods for doing this. Less comprehensible, but more common, is to use hexadecimal. If you need a refresher on hexadecimal, please revisit lesson 4.12 -- Literals.

constexpr unsigned char mask0 { 0x1 }; // hex for 0000 0001

constexpr unsigned char mask1 { 0x2 }; // hex for 0000 0010

constexpr unsigned char mask2 { 0x4 }; // hex for 0000 0100

constexpr unsigned char mask3 { 0x8 }; // hex for 0000 1000

constexpr unsigned char mask4 { 0x10 }; // hex for 0001 0000

constexpr unsigned char mask5 { 0x20 }; // hex for 0010 0000

constexpr unsigned char mask6 { 0x40 }; // hex for 0100 0000

constexpr unsigned char mask7 { 0x80 }; // hex for 1000 0000

This can be a little hard to read. One way to make it easier is to use the left-shift operator to shift a bit into the proper location:

constexpr unsigned char mask0 { 1 << 0 }; // 0000 0001

constexpr unsigned char mask1 { 1 << 1 }; // 0000 0010

constexpr unsigned char mask2 { 1 << 2 }; // 0000 0100

constexpr unsigned char mask3 { 1 << 3 }; // 0000 1000

constexpr unsigned char mask4 { 1 << 4 }; // 0001 0000

constexpr unsigned char mask5 { 1 << 5 }; // 0010 0000

constexpr unsigned char mask6 { 1 << 6 }; // 0100 0000

constexpr unsigned char mask7 { 1 << 7 }; // 1000 0000

Testing a bit (to see if it is on or off)

Now that we have a set of bit masks, we can use these in conjunction with a bit flag variable to manipulate our bit flags.

To determine if a bit is on or off, we use bitwise AND in conjunction with the bit mask for the appropriate bit:

#include <iostream>

int main()

{

constexpr unsigned char mask0 = 0b0000'0001; // represents bit 0

constexpr unsigned char mask1 = 0b0000'0010; // represents bit 1

constexpr unsigned char mask2 = 0b0000'0100; // represents bit 2

constexpr unsigned char mask3 = 0b0000'1000; // represents bit 3

constexpr unsigned char mask4 = 0b0001'0000; // represents bit 4

constexpr unsigned char mask5 = 0b0010'0000; // represents bit 5

constexpr unsigned char mask6 = 0b0100'0000; // represents bit 6

constexpr unsigned char mask7 = 0b1000'0000; // represents bit 7

unsigned char flags{ 0b0000'0101 }; // 8 bits in size means room for 8 flags

std::cout << "bit 0 is " << ((flags & mask0) ? "on\n" : "off\n");

std::cout << "bit 1 is " << ((flags & mask1) ? "on\n" : "off\n");

return 0;

}

This prints:

bit 0 is on
bit 1 is off

Setting a bit

To set (turn on) a bit, we use bitwise OR equals (operator |=) in conjunction with the bit mask for the appropriate bit: