Как печатать (используя cout) способ хранения числа в памяти?

Я слежу за курсом колледжа об операционных системах, и мы учимся, как конвертировать из двоичного в шестнадцатеричное, десятичное в шестнадцатеричное и т.д., и сегодня мы просто узнали, как подписанные/неподписанные числа хранятся в памяти, используя два дополнения (~ число + 1).

У нас есть несколько упражнений, которые нужно сделать на бумаге, и я хотел бы иметь возможность проверить свои ответы, прежде чем отправлять свою работу учителю. Я написал программу на С++ для первых нескольких упражнений, но теперь я зациклился на том, как я могу проверить свой ответ со следующей проблемой:

char a, b;

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

b = a >> 3;

и нам нужно показать двоичное представление в памяти a, b и c.

Я сделал это на бумаге и дал мне следующие результаты (все двоичные представления в памяти чисел после двух дополнений):

a = 00111010 (это a char, поэтому 1 байт)

b = 00001000 (это a char, поэтому 1 байт)

c = 11111110 11000101 (это короткий, так что 2 байта)

Есть ли способ проверить мой ответ? Есть стандартный способ на С++, чтобы показать двоичное представление в памяти числа или мне нужно каждый раз закодировать каждый шаг (вычислить два дополнения, а затем преобразовать в двоичные)? Я знаю, что последнее не займет так много времени, но мне любопытно, есть ли стандартный способ сделать это.

179
08 сент. '11 в 17:30
источник поделиться
10 ответов

Возможно, самый простой способ - создать std::bitset представляющий значение, а затем передать его в 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';
350
08 сент. '11 в 17:35
источник

Связанные вопросы


Похожие вопросы

Используйте преобразование "на лету" в std::bitset. Нет временных переменных, нет циклов, нет функций, нет макросов.

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

Печать

a = 11000110
b = 11111000
c = 1111111011000101
88
17 марта '13 в 10:39
источник

Если вы хотите отобразить представление битов любого объекта, а не просто целое число, не забудьте сначала переинтерпретироваться как массив char, тогда вы можете распечатать содержимое этого массива в виде шестнадцатеричного или даже бинарного (через 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);
}

Обратите внимание, что большинство распространенных систем являются малориентированными, поэтому вывод show_binrep(c) не 1111111 011000101, которого вы ожидаете, потому что это не то, как он хранится в памяти. Если вы ищете представление значений в двоичном формате, то работает простой cout << bitset<16>(c).

23
08 сент. '11 в 17:40
источник

Подобно тому, что уже опубликовано, просто используя бит-сдвиг и маску, чтобы получить бит; пригодный для любого типа, являющийся шаблоном (только не уверенный, если есть стандартный способ получить число бит в 1 байте, я использовал 8 здесь).

#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);
    }
}
7
08 сент. '11 в 17:45
источник

Есть ли стандартный способ в С++ для отображения двоичного представления в памяти числа [...]?

Нет. Там нет std::bin, например std::hex или std::dec, но не сложно вывести двоичный код:

Вы выводите самый левый бит, маскируя все остальные, сдвигая влево и повторяя это для всех бит, которые у вас есть.

(Число бит в типе sizeof(T) * CHAR_BIT.)

7
08 сент. '11 в 17:35
источник

Многоразовая функция:

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

Использование:

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

Это работает со всеми видами целых чисел.

4
04 июня '18 в 8:47
источник
#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
}
1
04 нояб. '15 в 23:40
источник

Используя старую версию C++, вы можете использовать этот фрагмент:

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
0
15 апр. '19 в 2:29
источник

Вот верный способ получить двоичное представление числа:

unsigned int i = *(unsigned int*) &x;
-5
19 окт. '15 в 18:33
источник

Это то, что вы ищете?

std::cout << std::hex << val << std::endl;
-9
08 сент. '11 в 17:33
источник

Посмотрите другие вопросы по меткам или Задайте вопрос