Bitwise Operators

Integers in a computer are just sequences of bits. Bitwise operators let you work at that level.

They’re not something you’ll use in every program, but nothing else will do when you need direct control over individual bits.

Writing and printing binary values

Recall that C++ lets you write integer literals in binary with the 0b prefix (since C++14):

#include <iostream>#include <bitset>int main() {    unsigned int flags = 0b00001101;  // Same as 13    std::cout << std::bitset<8>(flags) << "\n";  // 00001101}

Terminal

On line 5, flags is initialized with a binary literal.

On line 6, std::bitset<8>(flags) prints flags as 8 binary digits. We use this throughout the lesson to see what each operator does to the bits.

Bitwise operators

There are six bitwise operators in C++. Here’s what each one does:

Bitwise AND (`&`)

a & b produces a number with a 1 in each bit position where both a and b have a 1.

Three rows of 8 boxes each representing 8-bit binary values. Row a shows 01101001 with 1-bits highlighted in green. Row b shows 00001111 with 1-bits highlighted in blue. Row a & b shows 00001001 with 1-bits highlighted in orange, corresponding to positions where both a and b had a 1.

Bitwise AND applied to two 8-bit values.

Here’s how it appears in code:

#include <iostream>#include <bitset>int main() {    unsigned int status = 0b01101001;  // Some status byte    unsigned int mask   = 0b00001111;  // Lower 4 bits are set to 1    unsigned int lower = status & mask; // Keep only the lower 4 bits    std::cout << std::bitset<8>(lower) << "\n";  // 00001001}

Terminal

Notice in the output that where mask has a 0 bit, the resulting bit is always 0; where mask has a 1 bit, the corresponding bit from status remains unchanged. This technique is called masking, where the mask is chosen carefully to reveal part of the data and suppress the rest of it.

Bitwise OR (`|`)

a | b produces a 1 in all bit positions where at least one of a or b has a 1.

Three rows of 8 boxes representing 8-bit binary values. Row a shows 01101001 with 1-bits highlighted in green. Row b shows 00001111 with 1-bits highlighted in blue. Row a | b shows 01101111 with 1-bits highlighted in orange, covering every position where either a or b had a 1.

Bitwise OR applied to two 8-bit values.

This code shows a simplified version of how file permissions work on Unix-like systems.

#include <iostream>#include <bitset>int main() {    unsigned int permissions = 0b00000000;  // Start with nothing    const unsigned int READ    = 0b00000001;    const unsigned int WRITE   = 0b00000010;    const unsigned int EXECUTE = 0b00000100;    permissions = permissions | READ | WRITE;  // Grant read and write    std::cout << std::bitset<8>(permissions) << "\n";  // 00000011}

Terminal

READ, WRITE, and EXECUTE are each flags: a flag is a value with exactly one bit set to 1. Here, a bit being set to 1 means permission is granted for that task: reading, writing, or executing a file.

Since no two flags share the same bit, you can combine them safely with |. Here, the value in permissions ends up as 00000011, meaning read and write permissions are both granted.

Bitwise XOR (`^`)

a ^ b produces a 1 only in bit positions where a and b differ.

#include <iostream>#include <bitset>int main() {    unsigned int state  = 0b00000101;    unsigned int TOGGLE = 0b00000110;    std::cout << "state:    " << std::bitset<8>(state)  << "\n";    std::cout << "TOGGLE:   " << std::bitset<8>(TOGGLE) << "\n";    std::cout << "Result:   " << std::bitset<8>(state ^ TOGGLE) << "\n";}

Terminal

XOR-ing a value with the same number twice always gives back the original value. That’s an idea used by simpler encryption schemes, where you apply the same operation to encrypt a piece of data and recover it later.

Four rows of 8 boxes representing 8-bit binary values. Row a shows 01101001 with 1-bits highlighted in green. Row b shows 00001111 with 1-bits highlighted in blue. Row a ^ b shows 01100110 with 1-bits highlighted in orange, where a and b differ. Row a ^ b ^ b shows 01101001, matching a exactly, with 1-bits highlighted in green, demonstrating that XOR-ing twice with the same value restores the original.

XOR-ing a value with the same number twice returns the original value.

Bitwise NOT (`~`)

~a inverts every bit in a. Every 0 becomes 1, every 1 becomes 0.

#include <iostream>#include <bitset>int main() {    unsigned int mask = 0b00001111;    std::cout << std::bitset<8>(~mask) << "\n";  // 11110000}

Terminal

Left shift (`<<`)

Left shift moves every bit to the left by some number of positions. Zeros fill in the vacated positions on the right, and the bits that are pushed beyond the left boundary are discarded.

#include <iostream>#include <bitset>int main() {    unsigned int x = 131;  // 10000011 in binary    std::cout << std::bitset<8>(x) << "\n";  // Original number    std::cout << std::bitset<8>(x << 1) << "\n";  // One shift    std::cout << std::bitset<8>(x << 2) << "\n";  // Two shifts}

Terminal

Now, each shift has the effect of doubling the value, as long as no 1 bits are pushed out of the left boundary. This is similar to how adding a zero to the end of a decimal number multiplies it by ten.

The following diagram shows what happens when the number 11 is shifted by two places. It results in the number 11x4 = 44.

Two rows of 8 boxes representing 8-bit binary values. Row a shows 00001011, the binary representation of 11, with 1-bits highlighted in green. Row a << 2 shows 00101100, the binary representation of 44, with 1-bits highlighted in blue, showing the bits of a shifted two positions to the left with zeros filled in on the right.

Left shifting a by 2 positions, where a = 11, produces 44.

Right shift (`>>`)

Right shift moves every bit to the right by some number of positions. Each move to the right halves the value, dropping any remainder.

#include <iostream>#include <bitset>int main() {    unsigned int x = 12;    std::cout << std::bitset<8>(x) << "\n";       // 00001100    std::cout << std::bitset<8>(x >> 1) << "\n";  // 00000110    std::cout << std::bitset<8>(x >> 2) << "\n";  // 00000011}

Terminal

Shifting a signed integer can give you unexpected results because of how negative numbers are represented. You should always use unsigned int (or uint8_t, uint32_t etc.) when shifting, not plain int.

Compound assignment forms

Like arithmetic operators, all the bitwise operators have compound assignment versions:

permissions |=  READ;       // Same as: permissions = permissions | READpermissions &= ~WRITE;      // Sets the write bit to 0, leaves others unchangedstate       ^=  TOGGLE;     // Toggle the bits in state where TOGGLE has a 1value       <<= 3;          // Shift left 3 placesvalue       >>= 2;          // Shift right 2 places

You’ll see these a lot in low-level and embedded systems code.

Checkpoint

1 / 3

Which operator would you use to check whether a particular bit is 1 in a value?

2 / 3

You have a variable settings and want to turn on a feature represented by the flag DARK_MODE without affecting any other settings. Which line does that correctly?

3 / 3

You left shift the value 200 (11001000 in binary) by 1 position inside an 8-bit value. What happens?

Previous Next

Bitwise Operators

Integers in a computer are just sequences of bits. Bitwise operators let you work at that level.

They’re not something you’ll use in every program, but nothing else will do when you need direct control over individual bits.

Writing and printing binary values

Recall that C++ lets you write integer literals in binary with the 0b prefix (since C++14):

#include <iostream>#include <bitset>int main() {    unsigned int flags = 0b00001101;  // Same as 13    std::cout << std::bitset<8>(flags) << "\n";  // 00001101}

Terminal

On line 5, flags is initialized with a binary literal.

On line 6, std::bitset<8>(flags) prints flags as 8 binary digits. We use this throughout the lesson to see what each operator does to the bits.

Bitwise operators

There are six bitwise operators in C++. Here’s what each one does:

Bitwise AND (`&`)

a & b produces a number with a 1 in each bit position where both a and b have a 1.

Bitwise AND applied to two 8-bit values.

Here’s how it appears in code:

#include <iostream>#include <bitset>int main() {    unsigned int status = 0b01101001;  // Some status byte    unsigned int mask   = 0b00001111;  // Lower 4 bits are set to 1    unsigned int lower = status & mask; // Keep only the lower 4 bits    std::cout << std::bitset<8>(lower) << "\n";  // 00001001}

Terminal

Bitwise OR (`|`)

a | b produces a 1 in all bit positions where at least one of a or b has a 1.

Bitwise OR applied to two 8-bit values.

This code shows a simplified version of how file permissions work on Unix-like systems.

#include <iostream>#include <bitset>int main() {    unsigned int permissions = 0b00000000;  // Start with nothing    const unsigned int READ    = 0b00000001;    const unsigned int WRITE   = 0b00000010;    const unsigned int EXECUTE = 0b00000100;    permissions = permissions | READ | WRITE;  // Grant read and write    std::cout << std::bitset<8>(permissions) << "\n";  // 00000011}

Terminal

Since no two flags share the same bit, you can combine them safely with |. Here, the value in permissions ends up as 00000011, meaning read and write permissions are both granted.

Bitwise XOR (`^`)

a ^ b produces a 1 only in bit positions where a and b differ.

#include <iostream>#include <bitset>int main() {    unsigned int state  = 0b00000101;    unsigned int TOGGLE = 0b00000110;    std::cout << "state:    " << std::bitset<8>(state)  << "\n";    std::cout << "TOGGLE:   " << std::bitset<8>(TOGGLE) << "\n";    std::cout << "Result:   " << std::bitset<8>(state ^ TOGGLE) << "\n";}

Terminal

XOR-ing a value with the same number twice returns the original value.

Bitwise NOT (`~`)

~a inverts every bit in a. Every 0 becomes 1, every 1 becomes 0.

#include <iostream>#include <bitset>int main() {    unsigned int mask = 0b00001111;    std::cout << std::bitset<8>(~mask) << "\n";  // 11110000}

Terminal

Left shift (`<<`)

Left shift moves every bit to the left by some number of positions. Zeros fill in the vacated positions on the right, and the bits that are pushed beyond the left boundary are discarded.

#include <iostream>#include <bitset>int main() {    unsigned int x = 131;  // 10000011 in binary    std::cout << std::bitset<8>(x) << "\n";  // Original number    std::cout << std::bitset<8>(x << 1) << "\n";  // One shift    std::cout << std::bitset<8>(x << 2) << "\n";  // Two shifts}

Terminal

The following diagram shows what happens when the number 11 is shifted by two places. It results in the number 11x4 = 44.

Left shifting a by 2 positions, where a = 11, produces 44.

Right shift (`>>`)

Right shift moves every bit to the right by some number of positions. Each move to the right halves the value, dropping any remainder.

#include <iostream>#include <bitset>int main() {    unsigned int x = 12;    std::cout << std::bitset<8>(x) << "\n";       // 00001100    std::cout << std::bitset<8>(x >> 1) << "\n";  // 00000110    std::cout << std::bitset<8>(x >> 2) << "\n";  // 00000011}

Terminal

Shifting a signed integer can give you unexpected results because of how negative numbers are represented. You should always use unsigned int (or uint8_t, uint32_t etc.) when shifting, not plain int.

Compound assignment forms

Like arithmetic operators, all the bitwise operators have compound assignment versions:

permissions |=  READ;       // Same as: permissions = permissions | READpermissions &= ~WRITE;      // Sets the write bit to 0, leaves others unchangedstate       ^=  TOGGLE;     // Toggle the bits in state where TOGGLE has a 1value       <<= 3;          // Shift left 3 placesvalue       >>= 2;          // Shift right 2 places

You’ll see these a lot in low-level and embedded systems code.

Checkpoint

1 / 3

Which operator would you use to check whether a particular bit is 1 in a value?

2 / 3

You have a variable settings and want to turn on a feature represented by the flag DARK_MODE without affecting any other settings. Which line does that correctly?

3 / 3

You left shift the value 200 (11001000 in binary) by 1 position inside an 8-bit value. What happens?

Previous Next

Bitwise Operators

Writing and printing binary values

Bitwise operators

Bitwise AND (&)

Bitwise OR (|)

Bitwise XOR (^)

Bitwise NOT (~)

Left shift (<<)

Right shift (>>)

Compound assignment forms

Checkpoint

Bitwise Operators

Writing and printing binary values

Bitwise operators

Bitwise AND (&)

Bitwise OR (|)

Bitwise XOR (^)

Bitwise NOT (~)

Left shift (<<)

Right shift (>>)

Compound assignment forms

Checkpoint

Bitwise AND (`&`)

Bitwise OR (`|`)

Bitwise XOR (`^`)

Bitwise NOT (`~`)

Left shift (`<<`)

Right shift (`>>`)

Bitwise AND (`&`)

Bitwise OR (`|`)

Bitwise XOR (`^`)

Bitwise NOT (`~`)

Left shift (`<<`)

Right shift (`>>`)