O.2 — Bitwise Operators - Learn C++

The bitwise operators

C++ provides 6 bit manipulation operators, often called bitwise operators:

Author’s note

In the following examples, we will largely be working with 4-bit binary values. This is for the sake of convenience and keeping the examples simple. In actual programs, the number of bits used is based on the size of the object (e.g. a 2 byte object would store 16 bits).

For readability, we’ll also omit the 0b prefix outside of code examples (e.g. instead of 0b0101, we’ll just use 0101).

The bitwise operators are defined for integral types and std::bitset. We’ll use std::bitset in our examples because it’s easier to print the output in binary.

Avoid using the bitwise operators with signed operands, as many operators will return implementation-defined results prior to C++20 or have other potential gotchas that are easily avoided by using unsigned operands (or std::bitset).

Best practice

To avoid surprises, use the bitwise operators with unsigned operands or std::bitset.

Bitwise left shift (<<) and bitwise right shift (>>) operators

The bitwise left shift (<<) operator shifts bits to the left. The left operand is the expression to shift the bits of, and the right operand is an integer number of bits to shift left by.

So when we say x << 1, we are saying “shift the bits in the variable x left by 1 place”. New bits shifted in from the right side receive the value 0.

0011 << 1 is 01100011 << 2 is 11000011 << 3 is 1000

Note that in the third case, we shifted a bit off the end of the number! Bits that are shifted off the end of the binary number are lost forever.

The bitwise right shift (>>) operator shifts bits to the right.

1100 >> 1 is 01101100 >> 2 is 00111100 >> 3 is 0001

Note that in the third case we shifted a bit off the right end of the number, so it is lost.

Here’s an example of doing some bit shifting:#include <bitset> #include <iostream> int main() { std::bitset<4> x { 0b1100 }; std::cout << x << '\n'; std::cout << (x >> 1) << '\n'; // shift right by 1, yielding 0110 std::cout << (x << 1) << '\n'; // shift left by 1, yielding 1000 return 0; }

This prints:1100 0110 1000

For advanced readers

Bit-shifting in C++ is endian-agnostic. Left-shift is always towards the most significant bit, and right-shift towards the least significant bit.

What!? Aren’t operator<< and operator>> used for input and output?

They sure are.

Programs today typically do not make much use of the bitwise left and right shift operators to shift bits. Rather, you tend to see the bitwise left shift operator used with std::cout (or other stream objects) to output text. Consider the following program:#include <bitset> #include <iostream> int main() { unsigned int x { 0b0100 }; x = x << 1; // use operator<< for left shift std::cout << std::bitset<4>{ x } << '\n'; // use operator<< for output return 0; }

This program prints:1000

In the above program, how does operator<< know to shift bits in one case and output x in another case? The answer is that std::cout has overloaded (provided an alternate definition for) operator<< that does console output rather than bit shifting.

When the compiler sees that the left operand of operator<< is std::cout, it knows that it should call the version of operator<< that std::cout overloaded to do output. If the left operand is an integral type, then operator<< knows it should do its usual bit-shifting behavior.

The same applies for operator>>.

Note that if you’re using operator << for both output and left shift, parenthesization is required:#include <bitset> #include <iostream> int main() { std::bitset<4> x{ 0b0110 }; std::cout << x << 1 << '\n'; // print value of x (0110), then 1 std::cout << (x << 1) << '\n'; // print x left shifted by 1 (1100) return 0; }

This prints:01101 1100

The first line prints the value of x (0110), and then the literal 1. The second line prints the value of x left-shifted by 1 (1100).

We will talk more about operator overloading in a future chapter, including discussion of how to overload operators for your own purposes.

Bitwise NOT

The bitwise NOT operator (~) is perhaps the easiest to understand of all the bitwise operators. It simply flips each bit from a 0 to a 1, or vice versa. Note that the result of a bitwise NOT is dependent on what size your data type is.

Flipping 4 bits:~0100 is 1011

Flipping 8 bits:~0000 0100 is 1111 1011

In both the 4-bit and 8-bit cases, we start with the same number (binary 0100 is the same as 0000 0100 in the same way that decimal 7 is the same as 07), but we end up with a different result.

We can see this in action in the following program:#include <bitset> #include <iostream> int main() { std::cout << ~std::bitset<4>{ 0b0100 } << ' ' << ~std::bitset<8>{ 0b0100 } << '\n'; return 0; }

This prints:1011 11111011

Bitwise OR

Bitwise OR (|) works much like its logical OR counterpart. However, instead of applying the OR to the operands to produce a single result, bitwise OR applies to each bit! For example, consider the expression 0b0101 | 0b0110.

To do (any) bitwise operations, it is easiest to line the two operands up like this:0 1 0 1 OR 0 1 1 0

and then apply the operation to each column of bits.

If you remember, logical OR evaluates to true (1) if either the left, right, or both operands are true (1), and 0 otherwise. Bitwise OR evaluates to 1 if either the left, right, or both bits are 1, and 0 otherwise. Consequently, the expression evaluates like this:0 1 0 1 OR 0 1 1 0 ------- 0 1 1 1

Our result is 0111 binary.#include <bitset> #include <iostream> int main() { std::cout << (std::bitset<4>{ 0b0101 } | std::bitset<4>{ 0b0110 }) << '\n'; return 0; }

This prints:0111

We can do the same thing to compound OR expressions, such as 0b0111 | 0b0011 | 0b0001. If any of the bits in a column are 1, the result of that column is 1.0 1 1 1 OR 0 0 1 1 OR 0 0 0 1 -------- 0 1 1 1

Here’s code for the above:#include <bitset> #include <iostream> int main() { std::cout << (std::bitset<4>{ 0b0111 } | std::bitset<4>{ 0b0011 } | std::bitset<4>{ 0b0001 }) << '\n'; return 0; }

This prints:0111

Bitwise AND

Bitwise AND (&) works similarly to the above. Logical AND evaluates to true if both the left and right operand evaluate to true. Bitwise AND evaluates to true (1) if both bits in the column are 1. Consider the expression 0b0101 & 0b0110. Lining each of the bits up and applying an AND operation to each column of bits:0 1 0 1 AND 0 1 1 0 -------- 0 1 0 0 #include <bitset> #include <iostream> int main() { std::cout << (std::bitset<4>{ 0b0101 } & std::bitset<4>{ 0b0110 }) << '\n'; return 0; }

This prints:0100

Similarly, we can do the same thing to compound AND expressions, such as 0b0001 & 0b0011 & 0b0111. If all of the bits in a column are 1, the result of that column is 1.0 0 0 1 AND 0 0 1 1 AND 0 1 1 1 -------- 0 0 0 1 #include <bitset> #include <iostream> int main() { std::cout << (std::bitset<4>{ 0b0001 } & std::bitset<4>{ 0b0011 } & std::bitset<4>{ 0b0111 }) << '\n'; return 0; }

This prints:0001

Bitwise XOR

The last operator is the bitwise XOR (^), also known as exclusive or.

When evaluating two operands, XOR evaluates to true (1) if one and only one of its operands is true (1). If neither or both are true, it evaluates to 0. Consider the expression 0b0110 ^ 0b0011:0 1 1 0 XOR 0 0 1 1 ------- 0 1 0 1

It is also possible to evaluate compound XOR expression column style, such as 0b0001 ^ 0b0011 ^ 0b0111. If there are an even number of 1 bits in a column, the result is 0. If there are an odd number of 1 bits in a column, the result is 1.0 0 0 1 XOR 0 0 1 1 XOR 0 1 1 1 -------- 0 1 0 1

Bitwise assignment operators

Similar to the arithmetic assignment operators, C++ provides bitwise assignment operators in order to facilitate easy modification of variables.

For example, instead of writing x = x >> 1;, you can write x >>= 1;.#include <bitset> #include <iostream> int main() { std::bitset<4> bits { 0b0100 }; bits >>= 1; std::cout << bits << '\n'; return 0; }

This program prints:0010

As an aside…

There is no bitwise NOT assignment operator. This is because the other bitwise operators are binary, but bitwise NOT is unary (so what would go on the right-hand side of a ~= operator?). If you want to flip all of the bits, you can use normal assignment here: x = ~x;

Bitwise operators perform integral promotion on smaller integral types Advanced

If the operand(s) of a bitwise operator are an integral type smaller than an int, those operands will be promoted (converted) to int or unsigned int, and the result returned will also be an int or unsigned int. For example, if our operands are unsigned short, they will be promoted (converted) to unsigned int, and the result of the operation will be returned as an unsigned int.

In many cases, this won’t matter.

Related content

We cover integral promotion in lesson 10.2 -- Floating-point and integral promotion.

However, when using bitwise operators on integral types narrower than int or unsigned int, there are two cases to watch out for:

• operator~ and operator<< are width-sensitive and may produce different results depending on the width of the operand.
• Initializing or assigning the result to a variable of the smaller integral type is a narrowing conversion (since converting an int or unsigned int to a smaller integral type may result in data loss). This is disallowed in list initialization, and your compiler may or may not complain about a narrowing assignment.

The following program exhibits these issues (assuming 32-bit ints):#include <bitset> #include <cstdint> #include <iostream> int main() { std::uint8_t c { 0b00001111 }; std::cout << std::bitset<32>(~c) << '\n'; // incorrect: prints 11111111111111111111111111110000 std::cout << std::bitset<32>(c << 6) << '\n'; // incorrect: prints 0000000000000000001111000000 std::uint8_t cneg { ~c }; // error: narrowing conversion from unsigned int to std::uint8_t c = ~c; // possible warning: narrowing conversion from unsigned int to std::uint8_t return 0; }

These issues can be addressed by using static_cast to convert the result of your bitwise operation back to the narrower integral type. The following program produces the correct results:#include <bitset> #include <cstdint> #include <iostream> int main() { std::uint8_t c { 0b00001111 }; std::cout << std::bitset<32>(static_cast<std::uint8_t>(~c)) << '\n'; // correct: prints 00000000000000000000000011110000 std::cout << std::bitset<32>(static_cast<std::uint8_t>(c << 6)) << '\n'; // correct: prints 0000000000000000000011000000 std::uint8_t cneg { static_cast<std::uint8_t>(~c) }; // compiles c = static_cast<std::uint8_t>(~c); // no warning return 0; }

Warning

Bitwise operators will promote operands with narrower integral types to int or unsigned int.

operator~ and operator<< are width-sensitive and may produce different results depending on the width of the operand.

static_cast the result of such bitwise operations back to the narrower integral type before using to ensure correct results.

Summary

Summarizing how to evaluate bitwise operations utilizing the column method:

When evaluating bitwise OR, if any bit in a column is 1, the result for that column is 1.When evaluating bitwise AND, if all bits in a column are 1, the result for that column is 1.When evaluating bitwise XOR, if there are an odd number of 1 bits in a column, the result for that column is 1.

In the next lesson, we’ll explore how these operators can be used in conjunction with bit masks to facilitate bit manipulation.

Quiz time

Question #1

a) What does 0110 >> 2 evaluate to in binary?

Show Solution

0110 >> 2 evaluates to 0001

b) What does the following evaluate to in binary: 0011 | 0101?

Show Solution0 0 1 1 OR 0 1 0 1 -------- 0 1 1 1

c) What does the following evaluate to in binary: 0011 & 0101?

Show Solution0 0 1 1 AND 0 1 0 1 -------- 0 0 0 1

d) What does the following evaluate to in binary (0011 | 0101) & 1001?

Show SolutionInside the parenthesis: 0 0 1 1 OR 0 1 0 1 -------- 0 1 1 1 Then: 0 1 1 1 AND 1 0 0 1 -------- 0 0 0 1

Question #2

A bitwise rotation is like a bitwise shift, except that any bits shifted off one end are added back to the other end. For example 0b1001 << 1 would be 0b0010, but a left rotate by 1 would result in 0b0011 instead. Implement a function that does a left rotate on a std::bitset<4>. For this one, it’s okay to use test() and set().

The following code should execute:#include <bitset> #include <iostream> // "rotl" stands for "rotate left" std::bitset<4> rotl(std::bitset<4> bits) { // Your code here } int main() { std::bitset<4> bits1{ 0b0001 }; std::cout << rotl(bits1) << '\n'; std::bitset<4> bits2{ 0b1001 }; std::cout << rotl(bits2) << '\n'; return 0; }

and print the following:0010 0011

Show Solution#include <bitset> #include <iostream> std::bitset<4> rotl(std::bitset<4> bits) { // keep track of whether the leftmost bit was a 1 const bool leftbit{ bits.test(3) }; bits <<= 1; // do left shift (which shifts the leftmost bit off the end) // if the left bit was a 1 if (leftbit) bits.set(0); // set the rightmost bit to a 1 return bits; } int main() { std::bitset<4> bits1{ 0b0001 }; std::cout << rotl(bits1) << '\n'; std::bitset<4> bits2{ 0b1001 }; std::cout << rotl(bits2) << '\n'; return 0; }

We have named the function “rotl” rather than “rotateLeft”, because “rotl” is a well-established name in computer science and also the name of the standard function, std::rotl.

Question #3

Extra credit: Redo quiz #2 but don’t use the test and set functions (use bitwise operators).

Show HintHint: How might we get the leftmost bit into the rightmost position?

Show HintHint: Consider a “shift” in your perspective

Show Solution#include <bitset> #include <iostream> // h/t to reader Chris for this solution std::bitset<4> rotl(std::bitset<4> bits) { // bits << 1 does the left shift // bits >> 3 handle the rotation of the leftmost bit return (bits<<1) | (bits>>3); } int main() { std::bitset<4> bits1{ 0b0001 }; std::cout << rotl(bits1) << '\n'; std::bitset<4> bits2{ 0b1001 }; std::cout << rotl(bits2) << '\n'; return 0; }Next lessonO.3Bit manipulation with bitwise operators and bit masksBack to table of contentsPrevious lessonO.1Bit flags and bit manipulation via std::bitsetPrevious PostO.4 — Converting integers between binary and decimal representationNext Post7.1 — Compound statements (blocks)Label Name* Email*Your email address will not be displayedFind a mistake? Leave a comment above!Correction-related comments will be deleted after processing to help reduce clutter. Thanks for helping to make the site better for everyone!Avatars from https://gravatar.com/ are connected to your provided email address.Notify me about replies:   Label Name* Email*Your email address will not be displayedFind a mistake? Leave a comment above!Correction-related comments will be deleted after processing to help reduce clutter. Thanks for helping to make the site better for everyone!Avatars from https://gravatar.com/ are connected to your provided email address. 463 CommentsNewest Oldest Most VotedInline FeedbacksView all comments Load More Comments

©2024 Learn C++ Privacy PolicywpDiscuzInsertYou are going to send email to SendMove CommentMove