wake-up-neo.net

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

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;  
}
46
Ayrosa

Das funktioniert für mich in GCC:

#include  <iostream>
#include  <iomanip>

using namespace std;

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

Wenn Sie die Formatierungsfehler von Iostream satt haben, geben Sie Boost.Format einen Versuch. Es erlaubt althergebrachte Formatbezeichner im Printf-Stil und ist dennoch typsicher.

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

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

Verwenden Sie setw und setfill from 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;
}

Persönlich ärgert mich die Stateful-Natur von Iostreams immer. Ich denke, das Boost-Format ist eine bessere Option, also würde ich die andere Antwort empfehlen. 

16
Doug T.

Wenn Sie eine Hex-Zahl einfacher ausgeben möchten, können Sie eine Funktion wie folgt schreiben:

Die aktualisierte Version ist unten dargestellt. Es gibt zwei Möglichkeiten, den 0x-Basisindikator einzufügen, wobei Fußnoten die Unterschiede zwischen ihnen angeben. Die Originalversion bleibt am Ende der Antwort erhalten, um niemanden zu stören, der sie verwendet hat.

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

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();
}

Es 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 beide Optionen (siehe Fußnoten unten) live: hier .

Fußnoten:

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

    << "0x"
    << std::showbase
    
    • Die erste Option wird für benutzerdefinierte Typen, die versuchen, negative Hexadezimalzahlen als -0x## statt als <complement of 0x##> auszugeben, falsch angezeigt. Das Zeichen wird hinter der Basis (als 0x-##) anstatt davor angezeigt. Dies ist sehr selten ein Problem, daher bevorzuge ich diese Option.

      Wenn dies ein Problem ist, können Sie bei Verwendung dieser Typen vor der Ausgabe der Basis auf Negativität prüfen. Verwenden Sie dann abs() (oder eine benutzerdefinierte abs()), die einen vorzeichenlosen Wert zurückgibt, wenn Sie am meisten umgehen können -negative Werte auf einem 2er-Komplementsystem) auf val.

    • Bei der zweiten Option wird die Basis weggelassen, wenn val == 0 angezeigt wird (z. B. für int, wobei int 32 Bit ist) 0000000000 anstelle des erwarteten 0x00000000. Dies liegt daran, dass das showbase-Flag intern wie der #-Modifikator von printf() behandelt wird.

      Wenn dies ein Problem ist, können Sie prüfen, ob val == 0, und eine spezielle Behandlung anwenden, wenn dies der Fall ist.

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

    • Bei Verwendung von << "0x" ist HEX_BASE_CHARS nicht erforderlich und kann weggelassen werden.
    • Wenn Sie << std::showbase verwenden, muss der an setw() gelieferte Wert dies berücksichtigen:

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

Die ursprüngliche Version 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();
}

Was kann dann so 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: hier .

7
Justin Time

Wichtig ist, dass die Antwort fehlt: Sie müssen right mit allen oben genannten Flags verwenden:

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

Um die Ausgabe von Hex zu verkürzen, habe ich ein einfaches Makro erstellt

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

dann

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

Drucken Sie eine beliebige Zahl mit der automatischen Auffüllung '0' in den Hex-Bereich oder setzen Sie sie. Vorlage erlaubt jeden Datentyp (z. B. uint8_t)

template<typename T, typename baseT=uint32_t> 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<baseT>(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<baseT>(num.num_);

        return stream;
    }
};
template<typename T> tohex_t<T> TO_HEX(T const &num, bool showbase = false, uint32_t width = 0) { return tohex_t<T>(num, showbase, width); }

Beispiel:

std::stringstream 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();

Ausgabe:

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

versuchen Sie dies .. Sie voranstellen einfach Nullen basierend auf der Größe.

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

Sie können dies leicht ändern, um mit größeren Zahlen zu arbeiten.

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

Faktor ist 16 (für eine hexadezimale Ziffer):
16, 256, 4096, 65536, 1048576, ..
.__
0x10, 0x100, 0x1000, 0x10000, 0x100000, ..

Deshalb könntest du auch so schreiben ..

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

Und so weiter ..: P

0