Wie drucke (mit COUT) eine Zahl in binärer Form aus?

Question

Ich verfolge einen College -Kurs über Betriebssysteme und wir lernen, wie man von binär in hexadezimal, dezimal in hexadezimal usw. konvertiert. Heute haben wir gerade gelernt, wie signierte/unsignierte Zahlen mithilfe der Komplement der beiden im Speicher gespeichert werden (~ Nummer + 1).

Wir haben ein paar Übungen auf dem Papier zu machen und ich möchte meine Antworten überprüfen, bevor ich meine Arbeit an den Lehrer einreiche. Ich habe ein C ++ - Programm für die ersten Übungen geschrieben, aber jetzt bin ich festgefahren, wie ich meine Antwort mit dem folgenden Problem überprüfen konnte:

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 Komplement der beiden):

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 einen Standardweg in C ++, um die binäre Darstellung im Gedächtnis einer Zahl zu zeigen, oder muss ich jeden Schritt selbst codieren (berechnen Sie die Komplement der beiden und dann in binär)? Ich weiß, dass letzteres nicht so lange dauern würde, aber ich bin gespannt, ob es einen Standard -Weg gibt, dies zu tun.

Answer 1

Der einfachste Weg ist wahrscheinlich, eine zu schaffen std::bitset den Wert darstellen, dann den zu streamen 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';

Answer 2

Verwenden Sie die Konvertierung im Fliege zu std::bitset. Keine vorübergehenden 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

Answer 3

Wenn Sie die Bitdarstellung eines Objekts, nicht nur als Ganzzahl anzeigen möchten, denken Sie daran, zuerst als Zeichenarray 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 häufigsten Systeme Little-Endian sind, also die Ausgabe von show_binrep(c) ist nicht Die Sie erwarten, die 1111111 011000101, denn so wird es nicht im Speicher gespeichert. Wenn Sie suchen Wert Darstellung in Binärer, dann einfacher cout << bitset<16>(c) Arbeiten.

Answer 4

Gibt es einen Standardweg in C ++, um die binäre Darstellung im Gedächtnis einer Zahl [...] zu zeigen?

Nein, es gibt keine std::bin, wie std::hex oder std::dec, aber es ist nicht schwer, selbst eine Zahl -Binärin auszugeben:

Sie geben das linken Bit aus, indem Sie alle anderen maskieren, das linke Schicht links maskieren, und wiederholen das für alle Bits, die Sie haben.

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

Answer 5

Ähnlich wie bereits gepostet, verwenden Sie nur Bit-Shift und Maske, um das Stück zu erhalten. für jeden Typ verwendbar, eine Vorlage sein (Nur nicht sicher, ob es eine Standardmethode gibt, um eine Anzahl von Bits in 1 Byte zu erhalten, habe ich 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);
    }
}

Answer 6

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 Ganzzahlen.

Answer 7

#include <iostream> 
#include <cmath>       // in order to use pow() function
using namespace std; 

string show_binary(unsigned int u, int num_of_bits);

int main() 
{ 

  cout << show_binary(128, 8) << endl;   // should print 10000000
  cout << show_binary(128, 5) << endl;   // should print 00000
  cout << show_binary(128, 10) << endl;  // should print 0010000000

  return 0; 
}

string show_binary(unsigned int u, int num_of_bits) 
{ 
  string a = "";

  int t = pow(2, num_of_bits);   // t is the max number that can be represented

  for(t; t>0; t = t/2)           // t iterates through powers of 2
      if(u >= t){                // check if u can be represented by current value of t
          u -= t;
          a += "1";               // if so, add a 1
      }
      else {
          a += "0";               // if not, add a 0
      }

  return a ;                     // returns string
}

Answer 8

Mit der alten C ++ - Version können Sie diesen Snippet verwenden:

template<typename T>
string toBinary(const T& t)
{
  string s = "";
  int n = sizeof(T)*8;
  for(int i=n; i>=0; i--)
  {
    s += (t & (1 << i))?"1":"0";
  }
  return s;
}

int main()
{
  char a, b;

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

  b = a >> 3;

  cout << "a = " << a << " => " << toBinary(a) << endl;
  cout << "b = " << b << " => " << toBinary(b) << endl;
  cout << "c = " << c << " => " << toBinary(c) << endl;
}

a = ã => 111000110
b = ° => 111111000
c = -315 => 11111111011000101

Answer 9

Hier ist der wahre Weg, um eine binäre Darstellung einer Zahl zu erhalten:

unsigned int i = *(unsigned int*) &x;

Answer 10

Suchen Sie das?

std::cout << std::hex << val << std::endl;