Wie drucke ich (mit cout) eine Zahl in binärer Form?

Ich besuche einen College-Kurs über Betriebssysteme und wir lernen, wie man von binär zu hexadezimal, von dezimal zu hexadezimal usw. konvertiert + 1).

Wir müssen ein paar Übungen auf Papier machen und ich würde gerne meine Antworten überprüfen können, bevor ich meine Arbeit dem Lehrer schicke. Ich habe für die ersten paar Übungen ein C++-Programm geschrieben, aber jetzt stecke ich fest, wie ich meine Antwort mit dem folgenden Problem überprüfen könnte:

char a, b;

short c;
a = -58;
c = -315;

b = a >> 3;

und wir müssen die binäre Darstellung zeigen in Erinnerung von a, b und c.

Ich habe es auf Papier gemacht und es gibt mir die folgenden Ergebnisse (alle binären Darstellungen in Erinnerung an die Zahlen nach dem Zweierkomplement):

a = 00111010 (es ist ein Zeichen, also 1 Byte)

b = 00001000 (es ist ein Zeichen, also 1 Byte)

c = 11111110 11000101 (es ist kurz, also 2 Bytes)

Gibt es eine Möglichkeit, meine Antwort zu überprüfen? Gibt es in C++ eine Standardmethode, um die binäre Darstellung einer Zahl im Gedächtnis anzuzeigen, oder muss ich jeden Schritt selbst codieren (das Zweierkomplement berechnen und dann in binär konvertieren)? Ich weiß, dass letzteres nicht so lange dauern würde, aber ich bin gespannt, ob es einen Standardweg dafür gibt.

Der einfachste Weg ist wahrscheinlich, eine zu erstellen std::bitset den Wert darstellt, dann streamen Sie diesen zu cout.

#include <bitset>
...

char a = -58;
std::bitset<8> x(a);
std::cout << x << '\n';

short c = -315;
std::bitset<16> y(c);
std::cout << y << '\n';

Verwenden Sie die On-the-Fly-Konvertierung in std::bitset. Keine temporären Variablen, keine Schleifen, keine Funktionen, keine Makros.

Lebe auf Coliru

#include <iostream>
#include <bitset>

int main() {
    int a = -58, b = a>>3, c = -315;

    std::cout << "a = " << std::bitset<8>(a)  << std::endl;
    std::cout << "b = " << std::bitset<8>(b)  << std::endl;
    std::cout << "c = " << std::bitset<16>(c) << std::endl;
}

Drucke:

a = 11000110
b = 11111000
c = 1111111011000101

In C++20 können Sie verwenden std::format um dies zu tun:

unsigned char a = -58;
std::cout << std::format("{:b}", a);

Ausgabe:

11000110

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

unsigned char a = -58;
fmt::print("{:b}", a);

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

Wenn Sie die Bit-Darstellung eines beliebigen Objekts anzeigen möchten, nicht nur eine Ganzzahl, denken Sie daran, zuerst als Char-Array neu zu interpretieren, dann können Sie den Inhalt dieses Arrays als Hex oder sogar als Binär (über Bitset) drucken:

#include <iostream>
#include <bitset>
#include <climits>

template<typename T>
void show_binrep(const T& a)
{
    const char* beg = reinterpret_cast<const char*>(&a);
    const char* end = beg + sizeof(a);
    while(beg != end)
        std::cout << std::bitset<CHAR_BIT>(*beg++) << ' ';
    std::cout << '\n';
}
int main()
{
    char a, b;
    short c;
    a = -58;
    c = -315;
    b = a >> 3;
    show_binrep(a);
    show_binrep(b);
    show_binrep(c);
    float f = 3.14;
    show_binrep(f);
}

Beachten Sie, dass die meisten gebräuchlichen Systeme Little-Endian sind, also die Ausgabe von show_binrep(c) ist nicht die 1111111 011000101, die Sie erwarten, weil sie nicht so im Speicher gespeichert ist. Wenn Sie suchen Wert Darstellung in binär, dann eine einfache cout << bitset<16>(c) funktioniert.

Gibt es in C++ eine Standardmethode, um die binäre Darstellung einer Zahl im Speicher anzuzeigen? […]?

Nein. Es gibt keine std::binwie std::hex oder std::decaber es ist nicht schwer, selbst eine binäre Zahl auszugeben:

Sie geben das Bit ganz links aus, indem Sie alle anderen maskieren, nach links verschieben und dies für alle Bits wiederholen, die Sie haben.

(Die Anzahl der Bits in einem Typ ist sizeof(T) * CHAR_BIT.)

Ähnlich wie bei dem, was bereits gepostet wurde, verwenden Sie einfach Bit-Shift und Mask, um das Bit zu erhalten. verwendbar für jeden Typ, als Vorlage (Ich bin mir nur nicht sicher, ob es eine Standardmethode gibt, um die Anzahl der Bits in 1 Byte zu erhalten. Ich habe hier 8 verwendet).

#include<iostream>
#include <climits>

template<typename T>
void printBin(const T& t){
    size_t nBytes=sizeof(T);
    char* rawPtr((char*)(&t));
    for(size_t byte=0; byte<nBytes; byte++){
        for(size_t bit=0; bit<CHAR_BIT; bit++){
            std::cout<<(((rawPtr[byte])>>bit)&1);
        }
    }
    std::cout<<std::endl;
};

int main(void){
    for(int i=0; i<50; i++){
        std::cout<<i<<": ";
        printBin(i);
    }
}

Wiederverwendbare Funktion:

template<typename T>
static std::string toBinaryString(const T& x)
{
    std::stringstream ss;
    ss << std::bitset<sizeof(T) * 8>(x);
    return ss.str();
}

Verwendungszweck:

int main(){
  uint16_t x=8;
  std::cout << toBinaryString(x);
}

Dies funktioniert mit allen Arten von ganzen Zahlen.