Consider an unsigned char v that goes through a series of bit-wise operations with the result stored back to v. Under the hood, it is integer promoted once, undergoes a series of operations, and the result is truncated and stored back to v.
With std::byte v, however, for each and every operation, the operand is first integer promoted, undergoes the operation, and the (intermediate) result is truncated and stored back to some std::byte. That would be many back-and-forth promotion and truncation. This is all conceptual, but would it cause real overhead in practice?
Artificial Example
// `mask` and `lshf` are of type `unsigned`
unsigned char v = ...;
v = (v & mask) << lshf; // one promotion at `&` and one truncation at `=`
// `mask` and `lshf` are of type `std::byte` and `unsigned`
std::byte v = ...;
v = (v & mask) << lshf;
// It would be like
// byte(unsigned(byte(unsigned(v) & unsigned(mask))) << lshf)
Real-Case Example
Let's say we want to zero out the leading 3 bits of a byte.
unsigned char v = ...;
v = (v << 3 & 0xff) >> 3;
vs.
std::byte v = ...;
v = v << 3 >> 3;