c++ - matriz - Cómo imprimir(usando cout) la forma en que un número se almacena en la memoria?

matriz dinamica c

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 acabamos de aprender cómo los números firmados / no firmados se almacenan en la memoria usando el complemento de los dos (~ número + 1).

Tenemos un par de ejercicios para hacer en papel y me gustaría poder verificar mis respuestas antes de enviar mi trabajo al maestro. Escribí un programa en C ++ para los primeros ejercicios, pero ahora estoy atascado en cómo puedo 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 hice en papel y me da los siguientes resultados (todas las representaciones binarias en memoria de los números después del complemento a dos):

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

b = 00001000 (es un char, entonces 1 byte)

c = 11111110 11000101 (es un corto, por lo tanto, 2 bytes)

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

Answer 1

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

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

Sacas el bit más a la izquierda enmascarando todos los demás, desplaza hacia la izquierda y lo repites para todos los bits que tienes.

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

Answer 2

Es esto lo que estás buscando?

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

Answer 3

Esta es la verdadera forma de obtener una representación binaria de un número:

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

Answer 4

La forma más fácil es, probablemente, crear un std::bitset represente el valor, luego transmitirlo para cout .

#include <bitset>
...

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

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

Answer 5

Si desea visualizar la representación de bits de cualquier objeto, no solo un número entero, recuerde reinterpretarlo primero como una matriz de caracteres, luego puede imprimir el contenido de esa matriz, como hexadecimal, o incluso como binario (a través de conjuntos de bits):

#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 la mayoría de los sistemas comunes son little-endian, por lo que el resultado de show_binrep(c) no es el 1111111 011000101 que espera, porque no es así como está almacenado en la memoria. Si está buscando representación de valores en binario, entonces funciona un cout << bitset<16>(c) simple cout << bitset<16>(c) .

Answer 6

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

#include<iostream>

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 7

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

Live On 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 8

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