¿Cómo imprimir (usar cout) un número en forma binaria?

Question

Estoy siguiendo un curso universitario sobre sistemas operativos y estamos aprendiendo cómo convertir de binario a hexadecimal, decimal a hexadecimal, etc. y hoy aprendimos cómo los números firmados/sin firmar se almacenan en la memoria utilizando el complemento de los dos (~ número + 1).

Tenemos un par de ejercicios que hacer en papel y me gustaría poder verificar mis respuestas antes de enviar mi trabajo al maestro. Escribí un programa C ++ para los primeros ejercicios, pero ahora estoy atrapado en cómo podría verificar mi respuesta con el siguiente problema:

char a, b;

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

b = a >> 3;

y necesitamos mostrar la representación binaria en memoria de a, b y c.

Lo he hecho en papel y me da los siguientes resultados (todas las representaciones binarias en memoria de los números después del complemento de los dos):

a = 00111010 (es un char, entonces 1 byte)

b = 00001000 (es un carbón, entonces 1 byte)

C = 11111110 11000101 (es un corto, por lo que 2 bytes)

¿Hay alguna forma de verificar mi respuesta? ¿Hay una forma estándar en C ++ para mostrar la representación binaria en memoria de un número, o tengo que codificar cada paso yo mismo (calcule el complemento de los dos y luego me convierta a binario)? Sé que este último no tomaría tanto tiempo, pero tengo curiosidad por saber si hay una forma estándar de hacerlo.

Answer 1

La forma más fácil es probablemente crear un std::bitset representando el valor, luego transmitir que 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

Usar la conversión sobre la marcha std::bitset. Sin variables temporales, sin bucles, sin funciones, sin macros.

Vive en 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;
}

Huellas dactilares:

a = 11000110
b = 11111000
c = 1111111011000101

Answer 3

Si desea mostrar la representación de bit de cualquier objeto, no solo un entero, recuerde reinterpretar primero como una matriz de char, entonces puede imprimir el contenido de esa matriz, como hex o incluso como binario (a través de Bitset):

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

Tenga en cuenta que los sistemas más comunes son poco finios, por lo que la salida de show_binrep(c) es no El 1111111 011000101 que espera, porque no es así como se almacena en la memoria. Si estas buscando valor representación en binario, luego un simple cout << bitset<16>(c) obras.

Answer 4

¿Hay una forma estándar en C ++ para mostrar la representación binaria en memoria de un número [...]?

No. No hay std::bin, me gusta std::hex o std::dec, pero no es difícil generar un número binario usted mismo:

Usted genera la mayoría de la izquierda enmascarando a todos los demás, desplaza a la izquierda, y repite eso para todos los bits que tiene.

(El número de bits en un tipo es sizeof(T) * CHAR_BIT.)

Answer 5

Similar a lo que ya está publicado, solo usando bit-shift y enmascarar para obtener el bit; utilizable para cualquier tipo, ser una plantilla (Solo no estoy seguro si hay una forma estándar de obtener un número de bits en 1 byte, utilicé 8 aquí).

#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

Función reutilizable:

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

Uso:

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

Esto funciona con todo tipo de enteros.

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

Usando la versión antigua de C ++, puede usar este fragmento:

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

Aquí está la verdadera forma de obtener la representación binaria de un número:

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

Answer 10

¿Es esto lo que estás buscando?

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