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





разрядов кодирование (8)


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

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

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

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

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

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

char a, b;

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

b = a >> 3;

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

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

a = 00111010 (это символ, поэтому 1 байт)

b = 00001000 (это символ, поэтому 1 байт)

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

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




Если вы хотите отобразить представление битов любого объекта, а не целое число, не забудьте сначала интерпретировать его как массив символов, тогда вы можете распечатать содержимое этого массива как шестнадцатеричный или даже как двоичный (через битовый набор):

#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) , поэтому вывод show_binrep(c) не является ожидаемым 1111111 011000101, потому что это не то, как он хранится в памяти. Если вы ищете представление значений в двоичном формате, тогда работает простой cout << bitset<16>(c) .




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

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



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

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



Используйте преобразование «на лету» в 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



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

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



Самый простой способ - создать std::bitset представляющий значение, а затем передать его в 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;



Если вы используете мьютексы для защиты всех ваших данных, вам действительно не нужно беспокоиться. Мьютекс всегда обеспечивал достаточные гарантии заказа и видимости.

Теперь, если вы использовали атоматику или алгоритмы блокировки, вам нужно подумать о модели памяти. Модель памяти точно описывает, когда атомистика обеспечивает гарантии порядка и видимости, а также предоставляет переносные ограждения для ручных гарантий.

Раньше атомизация выполнялась с использованием встроенных компиляторов или некоторой библиотеки более высокого уровня. Заборы были бы выполнены с использованием инструкций, специфичных для процессора (барьеров памяти).





c++ binary iostream outputstream