shifting bits in a std::uint8_t

Question

I am trying to pack multiple indices into a byte (as defined by the GIF format):

std::uint8_t global_color_table_flag;    // bit  [0]
std::uint8_t color_resolution;           // bits [1-3]
std::uint8_t sort_flag;                  // bit  [4]
std::uint8_t global_color_table_size;    // bits [5-7]

I wanted to use

std::uint8_t field = (global_color_table_flag << 7) |
                     (color_resolution << 4) | (sort_flag << 3) |
                     (global_color_table_size);

but the left shift operator << promotes my std::uint8_t to int and the compiler complains (-Werror). Why is that so? Using it on an int does not promote it to a bigger int. It is just UB if you use it incorrectly to my understanding. Why is std::uint8_t any different?

If I use std::byte, the behavior is as expected. However, the code is rather ugly because of the issue mentioned above:

std::byte global_color_table_flag_byte{global_color_table_flag};
global_color_table_flag_byte <<= 7;

std::byte color_resolution_byte{color_resolution};
color_resolution_byte <<= 4;

std::byte sort_flag_byte{sort_flag};
sort_flag_byte <<= 3;

std::byte global_color_table_size_byte{global_color_table_size};

std::byte packed_field = global_color_table_flag_byte |
                         color_resolution_byte | sort_flag_byte |
                         global_color_table_size_byte;

file_stream << std::to_integer<std::uint8_t>(packed_field);

Is there a better way to proceed? As a side question, why can't I just write my std::byte to my binary stream? I thought the whole point of this type was to facilitate manipulation of such streams.

Answer 1

but the left shift operator << promotes my std::uint8_t to int and the compiler complains (-Werror). Why is that so?

Because you have enabled some compiler option that would warn in such case.

why the bit shift operator works differently on int and std::uint8_t.

Because std::uint8_t is a smaller type than int and therefore it is promoted. This is the same for all types smaller than int and all arithmetic operators, not just bit shift.

Is there a better way to proceed?

You could change the compiler options to not warn about correct expressions.

Or you could make some changes to the expression depending on what the compiler warns about. I cannot be more specific without knowing the warning.

I added all warnings

This is generally not very useful. Using -Wall is fine, but it doesn't enable all warnings for a reason. Many warning options excluded from it are counter-productive, have false-positives, or are simply intended for debugging the meaning of complex programs rather than inform about a problem.

why can't I just write my std::byte to my binary stream?

The proposal which added the type into the language didn't propose additional overloads for character streams. The proposal did not include a rationale for this choice. But I suspect it was to keep the changes minimal. I don't know if this was discussed by the committee.