Wie drucke ich Bytes als hexadezimal?

Gut können Sie konvertieren ein byte (unsigned char) in einer Zeit, in der ein array wie so

char buffer [17];
buffer[16] = 0;
for(j = 0; j < 8; j++)
    sprintf(&buffer[2*j], "%02X", data[j]);

InformationsquelleAutor der Antwort bentech

C:

static void print_buf(const char *title, const unsigned char *buf, size_t buf_len)
{
    size_t i = 0;
    fprintf(stdout, "%s\n", title);
    for(i = 0; i < buf_len; ++i)
    fprintf(stdout, "%02X%s", buf[i],
             ( i + 1 ) % 16 == 0 ? "\r\n" : " " );

}

C++:

void print_bytes(std::ostream& out, const char *title, const unsigned char *data, size_t dataLen, bool format = true) {
    out << title << std::endl;
    out << std::setfill('0');
    for(size_t i = 0; i < dataLen; ++i) {
        out << std::hex << std::setw(2) << (int)data[i];
        if (format) {
            out << (((i + 1) % 16 == 0) ? "\n" : " ");
        }
    }
    out << std::endl;
}

InformationsquelleAutor der Antwort user1763487

Drucken von beliebigen Strukturen in der modernen C++

Alle Antworten bisher nur sagen, wie es zu drucken eine Reihe von zahlen, aber wir können auch drucken Sie jede beliebige Struktur, da wir wissen, seine Größe. Das folgende Beispiel erstellt eine solche Struktur und durchläuft einen Zeiger durch seine bytes, Sie zu drucken, um die Ausgabe:

#include <iostream>
#include <iomanip>
#include <cstring>

using std::cout;
using std::endl;
using std::hex;
using std::setfill;
using std::setw;

using u64 = unsigned long long;
using u16 = unsigned short;
using f64 = double;

struct Header {
    u16 version;
    u16 msgSize;
};

struct Example {
    Header header;
    u64 someId;
    u64 anotherId;
    bool isFoo;
    bool isBar;
    f64 floatingPointValue;
};

int main () {
    Example example;
    //fill with zeros so padding regions don't contain garbage
    memset(&example, 0, sizeof(Example));
    example.header.version = 5;
    example.header.msgSize = sizeof(Example) - sizeof(Header);
    example.someId = 0x1234;
    example.anotherId = 0x5678;
    example.isFoo = true;
    example.isBar = true;
    example.floatingPointValue = 1.1;

    cout << hex << setfill('0');  //needs to be set only once
    auto *ptr = reinterpret_cast<unsigned char *>(&example);
    for (int i = 0; i < sizeof(Example); i++, ptr++) {
        if (i % sizeof(u64) == 0) {
            cout << endl;
        }
        cout << setw(2) << static_cast<unsigned>(*ptr) << " ";
    }

    return 0;
}

Und hier ist die Ausgabe:

05 00 24 00 00 00 00 00 
34 12 00 00 00 00 00 00 
78 56 00 00 00 00 00 00 
01 01 00 00 00 00 00 00 
9a 99 99 99 99 99 f1 3f

Hinweis dieses Beispiel zeigt auch Speicher Ausrichtung arbeiten. Wir sehen version besetzen 2 bytes (05 00), gefolgt von msgSize mit 2 Byte (24 00) und dann 4 Byte padding, danach kommt someId (34 12 00 00 00 00 00 00) und anotherId (78 56 00 00 00 00 00 00). Dann isFoodie belegt 1 byte (01) und isBarein weiteres byte (01), gefolgt von 6 bytes, padding, schließlich endend mit dem IEEE 754-standard für die Darstellung der Doppel-Feld floatingPointValue.

Beachten Sie auch, dass alle Werte dargestellt werden, wie little endian (least significant Byte zuerst kommen), da dies kompiliert und laufen auf einer Intel-Plattform.

InformationsquelleAutor der Antwort Lucio Paiva