Comment puis-je imprimer 0x0a au lieu de 0xa en utilisant cout?

Comment puis-je imprimer 0x0a au lieu de 0xa en utilisant cout?

#include  using std::cout; using std::endl; using std::hex; int main() { cout << hex << showbase << 10 << endl; } 

Cela fonctionne pour moi dans GCC:

 #include  #include  using namespace std; int main() { cout << "0x" << setfill('0') << setw(2) << hex << 10 << endl; } 

Si vous en avez assez de l'inquiétude du formatage d' iOStream, essayez Boost.Format . Il autorise les spécificateurs de format printf-style, bien vieux, mais il est de type sécurisé.

 #include  #include  int main() { std::cout << boost::format("0x%02x\n") % 10; } 

Utilisez setw et setfill de iomanip

 #include  #include  using std::cout; using std::endl; using std::hex; int main() { cout << "0x" << std::setfill('0') << std::setw(2) << hex << 10 << endl; } 

Personnellement, la nature dynamic des iostreams m'agace toujours. Je pense que le format boost est une meilleure option, alors j'avais recommandé l'autre réponse.

Si vous voulez faire un moyen plus facile de sortir un numéro hexadécimal, vous pourriez écrire une fonction comme ceci:

La version mise à jour est présentée ci-dessous; l’indicateur de base 0x peut être inséré de deux manières, avec des notes de bas de page détaillant les différences entre elles. La version originale est conservée au bas de la réponse, afin de ne pas gêner quiconque l’utilisait.

Notez que les versions à la fois mises à jour et originales peuvent nécessiter une personnalisation pour les systèmes dont la taille en octets est un multiple de 9 bits.

 namespace detail { constexpr int HEX_DIGIT_BITS = 4; //constexpr int HEX_BASE_CHARS = 2; // Optional. See footnote #2. // Replaced CharCheck with a much simpler trait. template struct is_char : std::integral_constant::value || std::is_same::value || std::is_same::value> {}; } template std::ssortingng hex_out_s(T val) { using namespace detail; std::ssortingngstream sformatter; sformatter << std::hex << std::internal << "0x" // See footnote #1. << std::setfill('0') << std::setw(sizeof(T) * CHAR_BIT / HEX_DIGIT_BITS) // See footnote #2. << (is_char::value ? static_cast(val) : val); return sformatter.str(); } 

Il peut être utilisé comme suit:

 uint32_t hexU32 = 0x0f; int hexI = 0x3c; unsigned short hexUS = 0x12; std::cout << "uint32_t: " << hex_out_s(hexU32) << '\n' << "int: " << hex_out_s(hexI) << '\n' << "unsigned short: " << hex_out_s(hexUS) << std::endl; 

Voir les deux options (comme détaillé dans les notes ci-dessous) en direct: ici .

Notes de bas de page:

  1. Cette ligne est responsable de l'affichage de la base et peut être l'une des suivantes:

     << "0x" << std::showbase 
    • La première option ne s'affichera pas correctement pour les types personnalisés qui essaient de sortir des nombres hexadécimaux négatifs sous la forme -0x## au lieu de , avec le signe affiché après la base ( 0x-## ) au lieu de . C'est très rarement un problème, donc je préfère personnellement cette option.

      S'il s'agit d'un problème, alors, si vous utilisez ces types, vous pouvez vérifier la négativité avant de sortir la base, puis utiliser abs() (ou un abs() personnalisé abs() qui renvoie une valeur non signée , si vous devez être capable de gérer le plus valeurs négatives sur un système de complément à 2) sur val .

    • La deuxième option omettra la base lorsque val == 0 , affichant (par exemple, pour int , où int est de 32 bits) 0000000000 au lieu de 0x00000000 attendu. Cela est dû au fait que le drapeau de la base de showbase est traité comme # modificateur de printf() interne.

      S'il s'agit d'un problème, vous pouvez vérifier si val == 0 et appliquer un traitement spécial lorsqu'il le fait.

  2. Selon l'option choisie pour afficher la base, deux lignes devront être modifiées.

    • Si vous utilisez << "0x" , alors HEX_BASE_CHARS est inutile et peut être omis.
    • Si vous utilisez << std::showbase , alors la valeur fournie à setw() doit en tenir compte:

       << std::setw((sizeof(T) * CHAR_BIT / HEX_DIGIT_BITS) + HEX_BASE_CHARS) 

La version originale est la suivante:

 // Helper structs and constants for hex_out_s(). namespace hex_out_helper { constexpr int HEX_DIGIT_BITS = 4; // One hex digit = 4 bits. constexpr int HEX_BASE_CHARS = 2; // For the "0x". template struct CharCheck { using type = T; }; template<> struct CharCheck { using type = char; }; template<> struct CharCheck { using type = char; }; template using CharChecker = typename CharCheck::type; } // namespace hex_out_helper template std::ssortingng hex_out_s(T val) { using namespace hex_out_helper; std::ssortingngstream sformatter; sformatter << std::hex << std::internal << std::showbase << std::setfill('0') << std::setw((sizeof(T) * CHAR_BIT / HEX_DIGIT_BITS) + HEX_BASE_CHARS) << (std::is_same, char>{} ? static_cast(val) : val); return sformatter.str(); } 

Qui peut alors être utilisé comme ceci:

 uint32_t hexU32 = 0x0f; int hexI = 0x3c; unsigned short hexUS = 0x12; std::cout << hex_out_s(hexU32) << std::endl; std::cout << hex_out_s(hexI) << std::endl; std::cout << "And let's not forget " << hex_out_s(hexUS) << std::endl; 

Exemple de travail: ici .

Pour raccourcir les choses pour la sortie de l’hex, j’ai fait une simple macro

 #define PADHEX(width, val) setfill('0') << setw(width) << std::hex << (unsigned)val 

puis

 cout << "0x" << PADHEX(2, num) << endl; 

Essayez ceci .. vous préférez simplement append des zéros en fonction de la magnitude.

 cout << hex << "0x" << ((c<16)?"0":"") << (static_cast(c) & 0xFF) << "h" << endl; 

Vous pouvez facilement modifier cela pour travailler avec des nombres plus importants.

 cout << hex << "0x"; cout << ((c<16)?"0":"") << ((c<256)?"0":""); cout << (static_cast(c) & 0xFFF) << "h" << endl; 

Le facteur est de 16 (pour un chiffre hexadécimal):
16, 256, 4096, 65536, 1048576, ..
respectif
0x10, 0x100, 0x1000, 0x10000, 0x100000, ..

Par conséquent, vous pouvez aussi écrire comme ça ..

 cout << hex << "0x" << ((c<0x10)?"0":"") << ((c<0x100)?"0":"") << ((c<0x1000)?"0":"") << (static_cast(c) & 0xFFFF) << "h" << endl; 

Et ainsi de suite ..: P

La chose importante qui manque à la réponse est que vous devez utiliser right tous les drapeaux mentionnés ci-dessus:

 cout<<"0x"< 

Imprimez n’importe quel nombre en hexadécimal avec un remplissage automatique ‘0’ ou défini. Template permet n’importe quel type de données (par exemple, uint8_t)

 template struct tohex_t { T num_; uint32_t width_; bool showbase_; tohex_t(T num, bool showbase = false, uint32_t width = 0) { num_ = num; showbase_ = showbase; width_ = width; } friend std::ostream& operator<< (std::ostream& stream, const tohex_t& num) { uint32_t w; baseT val; if (num.showbase_) stream << "0x"; if (num.width_ == 0) { w = 0; val = static_cast(num.num_); do { w += 2; val = val >> 8; } while (val > 0); } else { w = num.width_; } stream << std::hex << std::setfill('0') << std::setw(w) << static_cast(num.num_); return stream; } }; template tohex_t TO_HEX(T const &num, bool showbase = false, uint32_t width = 0) { return tohex_t(num, showbase, width); } 

Exemple:

 std::ssortingngstream sstr; uint8_t ch = 91; sstr << TO_HEX(5) << ',' << TO_HEX(ch) << ',' << TO_HEX('0') << std::endl; sstr << TO_HEX(1, true, 4) << ',' << TO_HEX(15) << ',' << TO_HEX(-1) << ','; sstr << TO_HEX(513) << ',' << TO_HEX((1 << 16) + 3, true); std::cout << sstr.str(); 

Sortie:

 05,5b,30 0x0001,0f,ffffffff,0201,0x010003