std::cout работает с uint8_t как с символом

Является ли это поведение стандартом

Поведение стандартное в том смысле, что если uint8_t является typedef для unsigned char, то он всегда будет печатать символ, поскольку std::ostream имеет перегрузку для unsigned char и выводит содержимое переменной в виде символа.

Не должен ли быть лучший способ определить uint8_t, который гарантированно будет обрабатываться как число, а не символ?

Для этого комитет C++ должен был ввести новый фундаментальный тип. В настоящее время единственными типами, у которых sizeof() равен 1, являются char, signed char и unsigned char. Возможно, они могли бы использовать bool, но bool не обязательно должен иметь размер 1, и тогда вы все еще в той же лодке, поскольку

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

будет печатать 1, а не 42, так как любое значение, отличное от нуля, равно true, а true печатается как 1, но по умолчанию.

Я не говорю, что это невозможно сделать, но это большая работа для чего-то, что можно обработать с помощью приведение или функция

C++17 представляет std::byte, который определяется как enum class byte : unsigned char {};. Таким образом, это будет один байт шириной, но это не символьный тип. К сожалению, поскольку это enum class, у него есть свои ограничения. Для него были определены побитовые операторы, но для него нет встроенных потоковых операторов, поэтому вам нужно будет определить свои собственные для ввода и вывода. Это означает, что вы все еще конвертируете его, но, по крайней мере, вы не будете конфликтовать со встроенными операторами для unsigned char. Это дает вам что-то вроде

std::ostream& operator <<(std::ostream& os, std::byte b)
{
    return os << std::to_integer<unsigned int>(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;
}

Публикация ответа, так как в комментариях есть некоторая дезинформация.

uint8_t может быть или не быть typedef для char или unsigned char. Также возможно, что это расширенный целочисленный тип (и, следовательно, не символьный тип).

Компиляторы могут предлагать другие целочисленные типы помимо минимального набора, требуемого стандартом (short, int, long и т. д.). Например, некоторые компиляторы предлагают 128-битный целочисленный тип.

Это также не будет «конфликтовать с C», поскольку C и C++ допускают расширенные целые типы.

Таким образом, ваш код должен учитывать обе возможности. Предложение в комментариях использовать унарный + будет работать.

Лично я думаю, что было бы более разумно, если бы стандарт требовал, чтобы uint8_t не был символьным типом, поскольку поведение, которое вы заметили, неинтуитивно.

Это косвенно стандартное поведение, потому что ostream имеет перегрузку для unsigned char, а unsigned char является typedef для того же типа uint8_t в вашей системе.

§27.7.3.1 [output.streams.ostream] дает:

template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, unsigned char);

Однако я не смог найти нигде в стандарте, где прямо указывалось бы, что uint8_t и unsigned char должны быть одинаковыми. Просто разумно, что они оба занимают 1 байт почти во всех реализациях.

 std::cout << std::boolalpha << std::is_same<uint8_t, unsigned char>::value << std::endl; // prints true

Чтобы получить значение для печати в виде целого числа, вам нужен тип, отличный от unsigned char (или одного из других перегруженных символов). Вероятно, достаточно простого приведения к uint16_t, потому что в стандарте для него не указана перегрузка:

uint8_t a = 65;
std::cout << static_cast<uint16_t>(a) << std::endl; // prints 65

Демо