Wie kann ich 0x0a anstelle von 0xa mit cout drucken?

Question

Wie kann ich 0x0a anstelle von 0xa mit cout drucken?

#include  <iostream>

using std::cout;  
using std::endl;  
using std::hex;

int main()  
{  
    cout << hex << showbase << 10 << endl;  
}

Answer 1

Das funktioniert bei mir im GCC:

#include  <iostream>
#include  <iomanip>

using namespace std;

int main()
{
    cout << "0x" << setfill('0') << setw(2) << right << hex << 10 << endl;
}

---

Wenn Sie die Formatierungswut von iostream satt haben, geben Sie Boost.Format einen Versuch. Es erlaubt gute altmodische, printf-ähnliche Formatspezifikationen und ist dennoch typsicher.

#include <iostream>
#include <boost/format.hpp>

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

---

UPDATE (2019)

Überprüfen Sie die Bibliothek {fmt} das akzeptiert wurde in C++20 . Benchmarks zeigen, dass es schneller als Boost.Format ist.

#if __has_include(<format>)
    #include <format>
    using std::format;
#else
    #include <fmt/format.h>
    using fmt::format;
#endif

std::cout << format("{:#04x}\n", 10);

Answer 2

Utilice setw y setfill von iomanip

#include  <iostream>
#include  <iomanip>

using std::cout;  
using std::endl;  
using std::hex;

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

Mich persönlich stört der zustandsbehaftete Charakter von iostreams immer. Ich denke, das Boost-Format ist eine bessere Option, daher würde ich die andere Antwort empfehlen.

Answer 3

Wenn Sie eine einfachere Möglichkeit zur Ausgabe einer Hexadezimalzahl suchen, könnten Sie eine Funktion wie die folgende schreiben:

Die aktualisierte Version wird unten dargestellt; es gibt zwei Möglichkeiten, die 0x Basisindikator eingefügt werden, mit Fußnoten, die die Unterschiede zwischen ihnen erläutern. Die ursprüngliche Version wird am Ende der Antwort beibehalten, um niemanden zu belästigen, der sie verwendet hat.

Beachten Sie, dass sowohl die aktualisierte als auch die ursprüngliche Version für Systeme, bei denen die Bytegröße ein Vielfaches von 9 Bit ist, möglicherweise etwas angepasst werden muss.

#include <type_traits> // For integral_constant, is_same.
#include <string>      // For string.
#include <sstream>     // For stringstream.
#include <ios>         // For hex, internal, [optional] showbase.
                       // Note: <ios> is unnecessary if <iostream> is also included.
#include <iomanip>     // For setfill, setw.
#include <climits>     // For CHAR_BIT.

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<typename T> struct is_char
      : std::integral_constant<bool,
                               std::is_same<T, char>::value ||
                               std::is_same<T, signed char>::value ||
                               std::is_same<T, unsigned char>::value> {};
}

template<typename T>
std::string hex_out_s(T val) {
    using namespace detail;

    std::stringstream 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<T>::value ? static_cast<int>(val) : val);

    return sformatter.str();
}

Sie kann wie folgt verwendet werden:

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;

Sehen Sie sich beide Optionen (wie in den Fußnoten unten beschrieben) live an: aquí .

Fußnoten:

1. Diese Zeile ist für die Darstellung der Basis verantwortlich und kann eine der folgenden sein:

   << "0x"
   << std::showbase

   • Die erste Option wird bei benutzerdefinierten Typen, die versuchen, negative Hex-Zahlen auszugeben, nicht korrekt angezeigt -0x## statt als <complement of 0x##> wobei das Vorzeichen nach der Basis angezeigt wird (wie 0x-## ) und nicht vor ihm. Dies ist sehr selten ein Problem, so dass ich persönlich diese Option bevorzuge.

     Wenn dies ein Problem ist, können Sie bei Verwendung dieser Typen vor der Ausgabe der Basis auf Negativität prüfen und dann mit abs() (o ein Brauch abs() die einen Wert ohne Vorzeichen zurückgibt wenn Sie in der Lage sein müssen, die höchstnegativen Werte in einem 2er-Komplement-System zu verarbeiten) auf val .

   • Bei der zweiten Option wird die Basis weggelassen, wenn val == 0 und zeigt (z. B. für int , donde int ist 32 Bit) 0000000000 statt der erwarteten 0x00000000 . Dies ist zurückzuführen auf die showbase Flagge, die behandelt wird wie printf() 's # Modifikator intern.

     Wenn dies ein Problem ist, können Sie prüfen, ob val == 0 und wenden Sie in diesem Fall eine Sonderbehandlung an.

2. Je nachdem, welche Option für die Darstellung der Basis gewählt wurde, müssen zwei Zeilen geändert werden.

   • Bei Verwendung von << "0x" entonces HEX_BASE_CHARS ist unnötig und kann weggelassen werden.

   • Bei Verwendung von << std::showbase dann wird der Wert, der an setw() muss diesem Umstand Rechnung tragen:

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

---

Die ursprüngliche Fassung lautet wie folgt:

// 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<typename T> struct CharCheck {
        using type = T;
    };

    template<> struct CharCheck<signed char> {
        using type = char;
    };

    template<> struct CharCheck<unsigned char> {
        using type = char;
    };

    template<typename T> using CharChecker = typename CharCheck<T>::type;
} // namespace hex_out_helper

template<typename T> std::string hex_out_s(T val) {
    using namespace hex_out_helper;

    std::stringstream 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<CharChecker<T>, char>{} ? static_cast<int>(val) : val);
    return sformatter.str();
}

Diese kann dann wie folgt verwendet werden:

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;

Arbeitsbeispiel: aquí .

Answer 4

In C++20 werden Sie in der Lage sein, Folgendes zu verwenden std::format um dies zu tun:

std::cout << std::format("{:02x}\n", 10);  

出力します。

0a

In der Zwischenzeit können Sie die {fmt}-Bibliothek , std::format basiert auf. {fmt} bietet auch die print Funktion, die dies noch einfacher und effizienter macht ( godbolt ):

fmt::print("{:02x}\n", 10); 

Haftungsausschluss : Ich bin der Autor von {fmt} und C++20 std::format .

Answer 5

Das Wichtigste, was in der Antwort fehlt, ist, dass Sie die right mit allen oben genannten Flaggen:

cout<<"0x"<<hex<<setfill('0')<<setw(2)<<right<<10;