Bitwise Operations

To perform bitwise operations on binary data, you'll typically use unsigned integer types like uint8_t, uint16_t, or uint32_t. These types allow you to directly manipulate individual bits using operators like & (AND), | (OR), ^ (XOR), and ~ (NOT).

Let's say you have two bytes of data represented as uint8_t variables, and you want to perform a bitwise AND operation:

1#include <cstdint>
2#include <iostream>
3#include <format>
4
5int main() {
6  uint8_t Byte1{0b11001100};
7  uint8_t Byte2{0b10101010};
8
9  // Bitwise AND
10  uint8_t Result = Byte1 & Byte2;
11
12  std::cout << std::format("{:b}", Result);
13}

110001000

In this example, Result will hold the value 0b10001000. Each bit in Result is set to 1 only if the corresponding bits in both Byte1 and Byte2 are 1.

Similarly, for a bitwise OR, you can use the | operator:

1#include <cstdint>
2#include <iostream>
3#include <format>
4
5int main() {
6  uint8_t Byte1{0b11001100};
7  uint8_t Byte2{0b10101010};
8
9  uint8_t Result = Byte1 | Byte2;  // Bitwise OR
10
11  std::cout << std::format("{:b}", Result);
12}

111101110

Here, Result will be 0b11101110. A bit in Result is set to 1 if either of the corresponding bits in Byte1 or Byte2 is 1.

For a bitwise XOR (exclusive OR), use the ^ operator:

1#include <cstdint>
2#include <iostream>
3#include <format>
4
5int main() {
6  uint8_t Byte1{0b11001100};
7  uint8_t Byte2{0b00101010};
8
9  // Bitwise XOR
10  uint8_t Result = Byte1 ^ Byte2;
11
12  std::cout << std::format("{:b}", Result);
13}

111100110

In this case, Result will be 0b11100110. A bit in Result is set to 1 if the corresponding bits in Byte1 and Byte2 are different.

Finally, the bitwise NOT operator ~ inverts the bits of a single operand:

1#include <cstdint>
2#include <iostream>
3#include <format>
4
5int main() {
6  uint8_t Byte1{0b01001100};
7
8  uint8_t Result = ~Byte1;  // Bitwise NOT
9
10  std::cout << std::format("{:b}", Result);
11}

110110011

Here, Result will be 0b00110011. Each bit in Byte1 is flipped (0 becomes 1, and 1 becomes 0).

std::byte is designed to represent a raw byte of data, and it does support bitwise operations. However, there are some nuances to be aware of:

Operations Between Two std::byte Objects

Bitwise operations are directly supported between two std::byte objects. The result of such operations is another std::byte.

1#include <cstddef>
2#include <iostream>
3
4int main() {
5  std::byte Byte1{0b11001100};
6  std::byte Byte2{0b10101010};
7
8  std::byte ResultAnd{Byte1 & Byte2}; // Bitwise AND
9  std::byte ResultOr{Byte1 | Byte2};  // Bitwise OR
10  std::byte ResultXor{Byte1 ^ Byte2}; // Bitwise XOR
11  std::byte ResultNot{~Byte1};        // Bitwise NOT
12
13  std::cout << "Result AND: "
14    << std::to_integer<int>(ResultAnd) << "\n";
15  std::cout << "Result OR: "
16    << std::to_integer<int>(ResultOr) << "\n";
17  std::cout << "Result XOR: "
18    << std::to_integer<int>(ResultXor) << "\n";
19  std::cout << "Result NOT: "
20    << std::to_integer<int>(ResultNot) << "\n";
21}

1Result AND: 136
2Result OR: 238
3Result XOR: 102
4Result NOT: 51

Operations Between std::byte and Integer Types

When you perform bitwise operations between a std::byte and an integer type (like int or uint8_t), the result is always a std::byte. The result of these operations is as follows:

• For operator&, operator|, operator^, operator&=, operator|=, and operator^=, an integral type is not supported as the right operand, but we can convert it to a std::byte in advance.
• For operator~, operator<<, operator>>, operator<<=, and operator>>=, the integer operand is treated as a count of bits, and the std::byte is shifted accordingly.

1#include <cstddef>
2
3int main() {
4  std::byte MyByte{0b00001111};
5
6  // Bit shifting a byte uses an integer
7  MyByte <<= 2;
8
9  // This won't work
10  MyByte &= 0b11110000;  
11
12  // But we can do this
13  MyByte &= std::byte{0b11110000};
14}

Casting with std::byte

The main purpose of std::byte is to indicate that you're working with raw data rather than arithmetic values.

However, if you need to perform arithmetic operations or use std::byte in contexts where an integer is expected, you can use std::to_integer:

1#include <cstddef>
2#include <iostream>
3
4int main() {
5  std::byte MyByte{42};
6
7  // Convert std::byte to an integer
8  int MyInt{std::to_integer<int>(MyByte)};
9
10  std::cout << "MyInt: " << MyInt << "\n";
11}

1MyInt: 42

While both std::byte and unsigned integers can represent raw bytes of data, their intended use cases are different:

• std::byte: Primarily for representing raw data where arithmetic operations are not meaningful. Bitwise operations are supported between two std::byte objects or between a std::byte and an integer.
• Unsigned Integers (e.g., uint8_t): Suitable for both raw data representation and numerical calculations. They support a wider range of operations, including arithmetic.

In summary, std::byte does support bitwise operations directly, and you don't need to cast to unsigned integers when working with two std::byte objects.

However, when mixing with integers or performing arithmetic, understanding the implicit conversions and using std::to_integer when needed is important.

The choice between std::byte and unsigned integers depends on whether you want to emphasize the raw data aspect or need numerical operations.