uint8_t ne peut pas être imprimé avec cout

J'ai un problème étrange à propos du travail avec des entiers en C ++.

J'ai écrit un programme simple qui définit une valeur sur une variable puis l'imprime, mais il ne fonctionne pas comme prévu.

Mon programme ne comporte que deux lignes de code:

uint8_t aa = 5;

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

La sortie de ce programme est value is

Ie, il imprime en blanc pour aa.

Quand je change uint8_tau uint16_tcode ci - dessus fonctionne comme un charme.

J'utilise Ubuntu 12.04 (Precise Pangolin), 64 bits, et ma version de compilateur est:

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

Il n'imprime pas vraiment un blanc, mais très probablement le caractère ASCII avec la valeur 5, qui est non imprimable (ou invisible). Il existe un certain nombre de codes de caractères ASCII invisibles , la plupart inférieurs à la valeur 32, qui est en fait le blanc.

Vous devez convertir aaen unsigned intpour afficher la valeur numérique, car ostream& operator<<(ostream&, unsigned char)essaie de générer la valeur du caractère visible.

uint8_t aa=5;

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

uint8_tsera probablement un typedefpour unsigned char. La ostreamclasse a une surcharge spéciale pour unsigned char, c'est-à-dire qu'elle imprime le caractère avec le numéro 5, qui n'est pas imprimable, d'où l'espace vide.

L'ajout d'un opérateur unaire + avant la variable de tout type de données primitif donnera une valeur numérique imprimable au lieu du caractère ASCII (dans le cas de type char).

uint8_t aa = 5;
cout<<"value is "<< +aa <<endl;

C'est parce que l'opérateur de sortie traite uint8_tcomme a char( uint8_test généralement juste un alias pour unsigned char), donc il imprime le caractère avec le code ASCII (qui est le système de codage de caractères le plus courant) 5.

Voir par exemple cette référence .

• Utilisation d' ADL (recherche de nom dépendante de l'argument):

  #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;
      }
  }

  production:

  *
  42

• Un manipulateur de flux personnalisé serait également possible.

• L'opérateur unaire plus est également un idiome ( cout << +i << endl).

couttraite aacomme une charvaleur ASCII 5qui est un caractère non imprimable, essayez le typage intavant d'imprimer.

La operator<<()surcharge entre istreamet charest une fonction non membre. Vous pouvez explicitement utiliser la fonction membre pour traiter a char(ou a uint8_t) comme un 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;
}

Production:

value is 5

Comme d'autres l'ont déjà dit, le problème se produit car le flux standard traite les caractères signés et non signés comme des caractères uniques et non comme des nombres.

Voici ma solution avec des changements de code minimes:

uint8_t aa = 5;

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

L'ajout "+0"est sécurisé avec n'importe quel nombre, y compris la virgule flottante.

Pour les types entiers, le type de résultat sera remplacé par intif sizeof(aa) < sizeof(int). Et cela ne changera pas de type si sizeof(aa) >= sizeof(int).

Cette solution est également bonne pour se préparer int8_tà être imprimé en streaming alors que certaines autres solutions ne sont pas si bonnes:

int8_t aa = -120;

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

Production:

value is -120
bad value is 4294967176

PS La solution avec ADL donnée par pepper_chico et πάντα ῥεῖ est vraiment belle.