std::cout deal with uint8_t as a character

Question

If I run this code:

std::cout << static_cast(65);

It will output:

A

Which

Answer 1

Is this behavior a standard

The behavior is standard in that if uint8_t is a typedef of unsigned char then it will always print a character as std::ostream has an overload for unsigned char and prints out the contents of the variable as a character.

Should not be a better way to define uint8_t that guaranteed to be dealt with as a number not a character?

In order to do this the C++ committee would have had to introduce a new fundamental type. Currently the only types that has a sizeof() that is equal to 1 is char, signed char, and unsigned char. It is possible they could use a bool but bool does not have to have a size of 1 and then you are still in the same boat since

int main()
{
    bool foo = 42;
    std::cout << foo << '\n';
}

will print 1, not 42 as any non zero is true and true is printed as 1 but default.

I'm not saying it can't be done but it is a lot of work for something that can be handled with a cast or a function

---

C++17 introduces std::byte which is defined as enum class byte : unsigned char {};. So it will be one byte wide but it is not a character type. Unfortunately, since it is an enum class it comes with it's own limitations. The bit-wise operators have been defined for it but there is no built in stream operators for it so you would need to define your own to input and output it. That means you are still converting it but at least you wont conflict with the built in operators for unsigned char. That gives you something like

std::ostream& operator <<(std::ostream& os, std::byte b)
{
    return os << std::to_integer(b);
}

std::istream& operator <<(std::istream& is, std::byte& b)
{
    unsigned int temp;
    is >> temp;
    b = std::byte{b};
    return is;
}

int main()
{
    std::byte foo{10};
    std::cout << foo;
}