uint8_t can't be printed with cout

Question

I wrote a simple program that sets a value to a variable and then prints it, but it is not working as expected. My program has only two lines of code:

uint8_t a = 5;

cout << "value is " << a << endl;

The output of this program is value is , i.e., it prints blank for a.

When I change uint8_t to uint16_t, the above code works like a charm.

I use Ubuntu 12.04 (Precise Pangolin), 64-bit, and my compiler version is:

gcc version 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5)

Answer 1

It doesn't really print a blank, but most probably the ASCII character with value 5, which is non-printable (or invisible). There's a number of invisible ASCII character codes, most of them below value 32, which is the blank actually.

You have to convert aa to unsigned int to output the numeric value, since ostream& operator<<(ostream&, unsigned char) tries to output the visible character value.

uint8_t aa=5;

cout << "value is " << unsigned(aa) << endl;

Answer 2

Adding a unary + operator before the variable of any primitive data type will yield a printable numerical value instead of an ASCII character (in case of char type).

uint8_t a = 5;
cout << "value is " << +a << endl; // value is 5

This works because +a result in a being promoted to int.

Answer 3

uint8_t will most likely be a typedef for unsigned char. The ostream class has a special overload for unsigned char, i.e. it prints the character with the number 5, which is non-printable, hence the empty space.

Answer 4

• Making use of ADL (Argument-dependent name lookup):

  #include <cstdint>
  #include <iostream>
  #include <typeinfo>
  
  namespace numerical_chars {
  inline std::ostream &operator<<(std::ostream &os, char c) {
      return std::is_signed<char>::value ? os << static_cast<int>(c)
                                         : os << static_cast<unsigned int>(c);
  }
  
  inline std::ostream &operator<<(std::ostream &os, signed char c) {
      return os << static_cast<int>(c);
  }
  
  inline std::ostream &operator<<(std::ostream &os, unsigned char c) {
      return os << static_cast<unsigned int>(c);
  }
  }
  
  int main() {
      using namespace std;
  
      uint8_t i = 42;
  
      {
          cout << i << endl;
      }
  
      {
          using namespace numerical_chars;
          cout << i << endl;
      }
  }
  

  output:

  *
  42
  

• A custom stream manipulator would also be possible.

• The unary plus operator is a neat idiom too (cout << +i << endl).

Answer 5

It's because the output operator treats the uint8_t like a char (uint8_t is usually just an alias for unsigned char), so it prints the character with the ASCII code (which is the most common character encoding system) 5.

See e.g. this reference.

Answer 6

cout is treating aa as char of ASCII value 5 which is an unprintable character, try typecasting to int before printing.

Answer 7

The operator<<() overload between std::ostream and char is a non-member function. You can explicitly use the member function to treat a char (or a uint8_t) as an int.

#include <iostream>
#include <cstddef>

int main()
{
   uint8_t aa=5;

   std::cout << "value is ";
   std::cout.operator<<(aa);
   std::cout << std::endl;

   return 0;
}

Output:

value is 5

Answer 8

As others said before the problem occurs because standard stream treats signed char and unsigned char as single characters and not as numbers.

Here is my solution with minimal code changes:

uint8_t aa = 5;

cout << "value is " << aa + 0 << endl;

Adding "+0" is safe with any number including floating point.

For integer types it will change type of result to int if sizeof(aa) < sizeof(int). And it will not change type if sizeof(aa) >= sizeof(int).

This solution is also good for preparing int8_t to be printed to stream while some other solutions are not so good:

int8_t aa = -120;

cout << "value is " << aa + 0 << endl;
cout << "bad value is " << unsigned(aa) << endl;

Output:

value is -120
bad value is 4294967176

P.S. Solution with ADL given by pepper_chico and πάντα ῥεῖ is really beautiful.