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

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:

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.

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:

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:

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:

This prints:

bit 1 is off
bit 1 is on

We can also turn on multiple bits at the same time using Bitwise OR:

Resetting a bit

To clear a bit (turn off), we use Bitwise AND and Bitwise NOT together:

This prints:

bit 2 is on
bit 2 is off

We can turn off multiple bits at the same time:

Flipping a bit

To toggle a bit state, we use Bitwise XOR:

This prints:

bit 2 is on
bit 2 is off
bit 2 is on

We can flip multiple bits simultaneously:

Bit masks and std::bitset

std::bitset supports the full set of bitwise operators. So even though it’s easier to use the functions (test, set, reset, and flip) to modify individual bits, you can use bitwise operators and bit masks if you want.

Why would you want to? The functions only allow you to modify individual bits. The bitwise operators allow you to modify multiple bits at once.

This prints:

bit 1 is off
bit 2 is on
bit 1 is on
bit 2 is off
bit 1 is on
bit 2 is on
bit 1 is off
bit 2 is off

Making bit masks meaningful

Naming our bit masks “mask1” or “mask2” tells us what bit is being manipulated, but doesn’t give us any indication of what that bit flag is actually being used for.

A best practice is to give your bit masks useful names as a way to document the meaning of your bit flags. Here’s an example from a game we might write:

Here’s the same example implemented using std::bitset:

Two notes here: First, std::bitset doesn’t have a nice function that allows you to query bits using a bit mask. So if you want to use bit masks rather than positional indexes, you’ll have to use Bitwise AND to query bits. Second, we make use of the any() function, which returns true if any bits are set, and false otherwise to see if the bit we queried remains on or off.

When are bit flags most useful?

Astute readers may note that the above examples don’t actually save any memory. 8 booleans would normally take 8 bytes. But the above examples use 9 bytes (8 bytes to define the bit masks, and 1 bytes for the flag variable)!

Bit flags make the most sense when you have many identical flag variables. For example, in the example above, imagine that instead of having one person (me), you had 100. If you used 8 Booleans per person (one for each possible state), you’d use 800 bytes of memory. With bit flags, you’d use 8 bytes for the bit masks, and 100 bytes for the bit flag variables, for a total of 108 bytes of memory -- approximately 8 times less memory.

For most programs, the amount of memory using bit flags saved is not worth the added complexity. But in programs where there are tens of thousands or even millions of similar objects, using bit flags can reduce memory use substantially. It’s a useful optimization to have in your toolkit if you need it.

There’s another case where bit flags and bit masks can make sense. Imagine you had a function that could take any combination of 32 different options. One way to write that function would be to use 32 individual Boolean parameters:

Hopefully you’d give your parameters more descriptive names, but the point here is to show you how obnoxiously long the parameter list is.

Then when you wanted to call the function with options 10 and 32 set to true, you’d have to do so like this:

This is ridiculously difficult to read (is that option 9, 10, or 11 that’s set to true?), and also means you have to remember which parameters corresponds to which option (is setting the “edit flag” the 9th, 10th, or 11th parameter?) It may also not be very performant, as every function call has to copy 32 booleans from the caller to the function.

Instead, if you defined the function using bit flags like this:

Then you could use bit flags to pass in only the options you wanted:

Not only is this much more readable, it’s likely to be more performant as well, since it only involves 2 operations (one Bitwise OR and one parameter copy).

This is one of the reasons OpenGL, a well regarded 3d graphic library, opted to use bit flag parameters instead of many consecutive Boolean parameters.

Here’s a sample function call from OpenGL:

GL_COLOR_BUFFER_BIT and GL_DEPTH_BUFFER_BIT are bit masks defined as follows (in gl2.h):

Bit masks involving multiple bits

Although bit masks often are used to select a single bit, they can also be used to select multiple bits. Lets take a look at a slightly more complicated example where we do this.

Color display devices such as TVs and monitors are composed of millions of pixels, each of which can display a dot of color. The dot of color is composed from three beams of light: one red, one green, and one blue (RGB). By varying the intensity of the colors, any color on the color spectrum can be made. Typically, the amount of R, G, and B for a given pixel is represented by an 8-bit unsigned integer. For example, a red pixel would have R=255, G=0, B=0. A purple pixel would have R=255, G=0, B=255. A medium-grey pixel would have R=127, G=127, B=127.

When assigning color values to a pixel, in addition to R, G, and B, a 4th value called A is often used. “A” stands for “alpha”, and it controls how transparent the color is. If A=0, the color is fully transparent. If A=255, the color is opaque.

R, G, B, and A are normally stored as a single 32-bit integer, with 8 bits used for each component:

32-bit RGBA value
bits 31-24 bits 23-16 bits 15-8 bits 7-0
red green blue alpha

The following program asks the user to enter a 32-bit hexadecimal value, and then extracts the 8-bit color values for R, G, B, and A.

This produces the output:

Enter a 32-bit RGBA color value in hexadecimal (e.g. FF7F3300): FF7F3300
Your color contains:
ff red
7f green
33 blue
0 alpha

In the above program, we use a bitwise AND to query the set of 8 bits we’re interested in, and then we right shift them into an 8-bit value so we can print them back as hex values.


Summarizing how to set, clear, toggle, and query bit flags:

To query bit states, we use bitwise AND:

To set bits (turn on), we use bitwise OR:

To clear bits (turn off), we use bitwise AND with bitwise NOT:

To flip bit states, we use bitwise XOR:

Quiz time

Question #1

Given the following program:

a) Write a line of code to set the article as viewed.

Show Solution

b) Write a line of code to check if the article was deleted.

Show Solution

c) Write a line of code to clear the article as a favorite.

Show Solution

1d) Extra credit: why are the following two lines identical?

Show Solution

O.4 -- Converting between binary and decimal
O.2 -- Bitwise operators

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

  • Hana

    Do you have a chapter on bit fields?

  • Jim

    Hi, Alex or nascar
    I have a question, why do we need to use bit masks in the program that extracts RGB colors from a hexadecimal value, when it can be done like this:

    • nascardriver

      Hi Jim

      There are several ways of extracting the individual values from an rgba number. I like yours, although it requires the reader to know how the conversion from `unsigned int` to `unsigned char` works. There are also purely arithmetic solutions, eg.

      Since those solutions, including yours, defeat the purpose of the code in the lesson, which is to teach bitwise operations, I'll leave the lesson as is.

  • Louis Cloete

    Hi Alex!

    Shouldn't the bit masks be declared constexpr rather than const?

  • avidlearner

    There might be a slight error on "Setting a bit" line 18: should be mask1, not mask4.

  • Pablo Asenjo Navas-Parejo

    Hi Alex or Nascar. Could you tell me why does this happen? If I initialize @eightflags to @mask3 and then I assing @eightflags the value of @eightflags & @mask3, it equals false, but if I assing @eighflags the value of @mask3 & @mask3, it equals true. I think this shouldn't happen since @eightflags is supposed to be equal to @mask3.


    Thank you!

  • Vishal

    Hey Alex, I  learn C,  C++,  Java,  HTML,  CSS3,  javascript,  python.  I almost understand all programming concepts of these modern programming languages but until now I don't build any cool stuff. I don't know what to do when I learn some new language. Alex please give me some suggestions to how I make or create some great stuff and what should I do when  I learne some new programming language.

    • Hey Vishal, I've found this website ( particularly useful as a wellspring of ideas for things to try out when you learn a new programming language.  The links within suggest everything from simple manipulation programs to complex and massive projects, so I'm sure there will be something for every level of experience and comfort.  The projects are almost all language-agnostic too, so you might even challenge your skills by trying to code the same thing in many of the languages you mentioned.  Happy coding, and welcome to the community!

  • Grego

    Hello Alex & Nascardriver,

    This may be a stupid question, but why are contants in this lesson assigned to and not initialized?
    I looked back to char variables and constants lessons and could see both of them showing proper initialization.
    What makes this type of a constant not need an initialisation? Am I just missing something obvious?

    • Alex

      These lessons are still in the process of being rewritten/updated, so they aren't yet compliant with all modern best practices. The constants here are being initialized (not assigned) via copy initialization rather than the now-preferred uniform/brace initialization.

  • learning

    what's wrong with this code? gives a warning:

    • is an `int`, `red` is a `char`. Converting from `int` to `char` could cause data loss. You're doing it on purpose and know that you're not losing data. Add a cast to silence the warning.

  • Sagar Pohekar

    Thanks for the tutorial.
    BTW, you said you are in process of replacing compile time/symbolic constants from 'const' to 'constexpr', so this tutorial is good place to use 'constexpr'


  • Alireza

    Hello and thank you so much for the Bit flags tutorial. This is very useful.

    question: Why have you used a char variable to use bit flags, Why haven't you used a bool variable or other ones to teach bit flags ?
    Does it mean especial ?

    Why the following program gives errors ?

    Imagine I write this program, which variable does bitset do ?

    • Alex

      std::bitset functions take bit positions, not bit masks. o1 works because it evaluates to bit 2, o2 works because it evaluates to bit 4, but o3 doesn't work because it evaluates to bit 8, which is out of range for a bitset of size 8.

      • Alireza

        Thanks for replying,
        So the inputed number in std::bitset as the size is not bits' number ; it is their values and must be equal to our flags.

        Sorry but you haven't answered it yet:

        Why have you used a char variable to use bit flags, Why haven't you used a bool variable or other ones to teach bit flags ?

        and one more question (important):

        Even though the value 128 is equal to 1000 0000 in binary, and 255 is equal to 1111 1111 in binary, so what's difference between std::bitset<128> and std::bitset<255> ?

        • Alex

          > So the inputed number in std::bitset as the size is not bits' number ; it is their values and must be equal to our flags.

          I read this a bunch of times and I'm not sure what you're trying to say.

          This line defines a std::bitset with a size of 8 bits, and initializes those bits to 0b'0000'0010. This is fine.

          This is invalid, as o2 is decimal value 8, and 8 is outside the range of our bitset. You actually meant:

          I use a char here because I want 8 bits, and unsigned because we should always use unsigned variables when dealing with bits. Bool is typically used for logical operations, not bitwise operations. It's bad practice to use bool in a bitwise context. I'm also not sure how well defined it is for use with bitwise operations.

          std::bitset<128> should define a bit field that holds 128 bits, and std::bitset<256> should define a bit field that holds 256 bits.

  • a700

    Hi, can you explain how this goes?
    if (myflags & option4)
        std::cout << "myflags has option 4 set";

    • bitwise-ands myflags with ...10000, ie. the result is all 0, and the fifth bit from the right is the same as in @myflags.
      If @myflags doesn't have this bit set, the result is 0.
      Non-zero integers evaluate to true, 0 evaluates to false.
      If the fifth bit from the right is set in @myflags, the condition is true.

  • Senna

    Why this webpage is broken down these days ?
    Is it temporary ?
    Don't stop supporting it, please.
    There's no source as simple, full contents as like learncpp.

    • Hi Senna!

      Quoting the index: "Feb 15: [Site News] Our server died yesterday and had to be restored from backups. We’re in the process of getting everything restored and reconfigured. If you find anything broken, please let us know here. Sorry for the inconvenience."

      If you want to continue reading while learncpp is down, you can do so on

    • Alex

      Yup, there was a hardware failure on the server. The site has been moved to a new server and should be up and running full-time (at least, until the next catastrophe). :)

Leave a Comment

Put all code inside code tags: [code]your code here[/code]